Content-type: text/html Manpage of ifort

ifort

Section: Intel(R) Fortran Compiler Options (1)
Updated: Intel Corporation
Index Return to Main Contents

ifort - invokes the Intel(R) Fortran Compiler  

SYNOPSIS

ifort [ options ] file1 [ file2 ]...

options
Are zero or more compiler options.
fileN
Is a Fortran source file, assembly file, object file, object library, or other linkable file.
 

DESCRIPTION - ifort

The ifort command invokes the Intel(R) Fortran Compiler XE that is designed to preprocess, compile, assemble, and link Fortran programs on systems using Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture), IA-32 architecture , and Intel(R) 64 architecture. If a description does not explicitly state a specific architecture, assume the description is applicable to all.

When there is a restriction, you will see "Architecture Restrictions", which will show the relevant restriction. For example:

Architecture Restrictions

Not available on Intel(R) 64 architecture, targeting Intel(R) MIC Architecture.

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 pre-processed 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.

This man page is intended for Linux* and OS X* users. However, sometimes you will see shortcuts for option names. You may see either or both of the following shortcuts:

*
If you see [Q]option-name, it means that the name of the option is the same on Linux*, OS X*, and Windows*, except that the Windows form starts with a Q. For example, if you see [Q]ip, the Linux and OS X form of the option is −ip and the Windows form of the option is /Qip.
*
If you see [q or Q]option-name, it means that the name of the option is very similar except that the Linux* and OS X* forms start with a q and the Windows form starts with a Q. For example, if you see [q or Q]opt-report, the Linux and OS X form of the option is −qopt-report and the Windows form of the option is /Qopt-report.

Otherwise, Linux* and OS X* compiler option names are shown with an initial [aq]−[aq].  

Options that Improve Run-Time Performance

The following command line options can be used to increase the run-time performance of code generated by the Intel(R) Fortran Compiler:

*
On systems using IA-32 architecture and systems using Intel(R) 64 architecture: -ax<processor>, -ftz, -ip, -ipo, -march=<processor>, -mtune=<processor>, -O[n], -openmp, -parallel, -prof-gen, -prof-use, -x<processor>.
 

Configuration and Indirect Files

Command options to be used whenever the compiler is invoked can be put into a system configuration file named ifort.cfg, which resides in the same area as the compiler.

The text in this file is processed by ifort before the text on the command line. To use a personal configuration file, set the environment variable IFORTCFG to point to the path and filename to be used.

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 "-i8 -r8" and file my_includes contains options "-I/bld/inc -I/bld/headers". In this case, the following command line: ifort -O3 @double_size myprog.f90 @my_includes passes "-O3 -i8 -r8 myprog.f90 -I/bld/inc -I/bld/headers" to the compiler.  

Feature Requirements

Some features may require that other products also be installed.

To use these tools and features, you need licensed versions of the tools and you must have an appropriate supported version of the relevant product edition. For more information, check your product release notes.

The following table shows components (tools) and some of the products with which they are included.

Component
Included with these Products
Intel(R) Inspector
Intel(R) Parallel Studio Professional Edition, Intel(R) Parallel Studio Cluster Edition
Intel(R) Trace Analyzer and Collector
Intel(R) Parallel Studio Cluster Edition

The following table lists dependent features and their corresponding required products.

For certain compiler options, compilation may fail if the option is specified but the required product is not installed. In this case, remove the option from the command line and recompile.

For more information about requirements for a particular product, see http://www.intel.com/software/products/.

*
Feature: Thread Checking Requirement: Intel(R) Inspector
*
Feature: Trace Analyzing and Collecting Requirement: Intel(R) Trace Analyzer and Collector Compiler options related to this feature may require a set-up script. For further information, see the documentation supplied with the required product.
*
Feature: Privatization of static data for the MPC unified parallel runtime Requirement: Appropriate elements of the MultiProcessor Computing (MPC) framework For more information, see http://mpc.sourceforge.net/

You should also refer to the Release Notes for this product for detailed information about system requirements, late changes to the products, supported architectures, operating systems, and Integrated Development Environments.  

OPTIONS

Some compiler options have the form -name keyword. Both -name and keyword can be abbreviated. It is recommended that you use the first four characters of each. For example, -assume buffered_io can be specified as -assu buff.

To see lists of compiler options by functionality, specify a category for option -help on the command line. For a list of the categories you can specify, see -help below.

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.

-align [keyword[, keyword...]]
-noalign
Tells the compiler how to align certain data items.
Arguments:
keyword
Specifies the data items to align. Possible values are:
none
Prevents padding bytes anywhere in common blocks and structures.
arraynbyte
Specifies a starting boundary for arrays.
[no]commons
Affects alignment of common block entities.
[no]dcommons
Affects alignment of common block entities.
[no]qcommons
Affects alignment of common block entities.
[no]zcommons
Affects alignment of common block entities.
[no]records
Affects alignment of derived-type components and fields of record structures.
recnbyte
Specifies a size boundary for derived-type components and fields of record structures.
[no]sequence
Affects alignment of sequenced derived-type components.
all
Adds padding bytes whenever possible to data items in common blocks and structures.
Default:
nocommons
Adds no padding bytes for alignment of common blocks.
nodcommmons
Adds no padding bytes for alignment of common blocks.
noqcommmons
Adds no padding bytes for alignment of common blocks.
nozcommmons
Adds no padding bytes for alignment of common blocks.
records
Aligns derived-type components and record structure fields on default natural boundaries.
nosequence
Causes derived-type components declared with the SEQUENCE statement to be packed, regardless of current alignment rules set by the user.

By default, no padding is added to common blocks but padding is added to structures.

Description:

This option specifies the alignment to use for certain data items. The compiler adds padding bytes to perform the alignment.

Option
Description
align none
Tells the compiler not to add padding bytes anywhere in common blocks or structures. This is the same as specifying noalign.
align arraynbyte
Aligns the start of arrays on an n-byte boundary. n can be 8, 16, 32, 64, 128, or 256. The default value for n is 8. This affects the starting alignment for all arrays except for arrays in COMMON.
Arrays do not have padding between their elements.
align commons
Aligns all common block entities on natural boundaries up to 4 bytes, by adding padding bytes as needed.
The align nocommons option adds no padding to common blocks. In this case, unaligned data can occur unless the order of data items specified in the COMMON statement places the largest numeric data item first, followed by the next largest numeric data (and so on), followed by any character data.
align dcommons
Aligns all common block entities on natural boundaries up to 8 bytes, by adding padding bytes as needed.
This option is useful for applications that use common blocks, unless your application has no unaligned data or, if the application might have unaligned data, all data items are four bytes or smaller. For applications that use common blocks where all data items are four bytes or smaller, you can specify align commons instead of align dcommons.
The align nodcommons option adds no padding to common blocks.
align qcommons
Aligns all common block entities on natural boundaries up to 16 bytes, by adding padding bytes as needed.
This option is useful for applications that use common blocks, unless your application has no unaligned data or, if the application might have u
naligned data, all data items are eight bytes or smaller. For applications that use common blocks where all data items are eight bytes or smaller, you can specify align dcommons instead of align qcommons.
The align noqcommons option adds no padding to common blocks.
align zcommons
Aligns all common block entities on natural boundaries up to 32 bytes, by adding padding bytes as needed.
This option is useful for applications that use
common blocks, unless your application has no unaligned data or, if the application might have unaligned data, all data items are 16 bytes or smaller. For applications that use common blocks where all data items are 16 bytes or smaller, you can specify align qcommons instead of align zcommons.
The align nozcommons option adds no padding to
common blocks.
align norecords
Aligns components of derived types and fields within record structures on arbitrary byte boundaries with no padding.
The align records option requests that multiple data items in record structures and derived-type structures without the SEQUENCE statement be naturally aligned, by adding padding as needed.
align recnbyte
Aligns components of derived types and fields within record structures on the smaller of the size boundary specified (n) or the boundary that will naturally align them. n can be 1, 2, 4, 8, 16, or 32. The default value for n is 8. When you specify this option, each structure member after the first is stored on either the size of the member type or n-byte boundaries, whichever is smaller. For example, to specify 16 bytes as the packing boundary (or alignment constraint) for all structures and unions in the file prog1.f, use the following command:
ifort {-align rec16byte | /align:rec16byte} prog1.f
This option does not affect whether common blocks are naturally aligned or packed.
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 align nosequence option requests that sequenced components be packed regardless of any other alignment rules. Note that align none implies align nosequence.
If you specify an option for standards checking, align sequence is ignored.
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 dcommons, align records, align nosequence. This is the same as specifying align with no keyword.
Alternate Options:
align none
Linux and OS X: -noalign
align records
Linux and OS X: -align rec16byte, -Zp16
align norecords
Linux and OS X: -Zp1, -align rec1byte
align recnbyte
Linux and OS X: -Zp{1|2|4|8|16}
align all
Linux and OS X: -align commons-align dcommons-align records-align nosequence
-allow keyword
Determines whether the compiler allows certain behaviors.
Arguments:
keyword
Specifies the behaviors to allow or disallow. Possible values are:
[no]fpp_comments
Determines how the fpp preprocessor treats Fortran end-of-line comments in preprocessor directive lines.
Default:
fpp_comments
The compiler recognizes Fortran-style end-of-line comments in preprocessor lines.
Description:

This option determines whether the compiler allows certain behaviors.

Option
Description
allow nofpp_comments
Tells the compiler to disallow Fortran-style end-of-line comments on preprocessor lines. Comment indicators have no special meaning.
Alternate Options:

None

-altparam
-noaltparam
Allows alternate syntax (without parentheses) for PARAMETER statements.
Arguments:

None

Default:
altparam
The alternate syntax for PARAMETER statements is allowed.
Description:

This option specifies that the alternate syntax for PARAMETER statements is allowed. The alternate syntax is:

PARAMETER c = expr [, c = expr] ...

This statement assigns a name to a constant (as does the standard PARAMETER statement), but there are no parentheses surrounding the assignment list.

In this alternative statement, the form of the constant, rather than implicit or explicit typing of the name, determines the data type of the variable.

Alternate Options:
altparam
Linux and OS X: None
noaltparam
Linux and OS X: None
-ansi-alias
-no-ansi-alias
Tells the compiler to assume that the program adheres to Fortran Standard type aliasability rules.
Arguments:

None

Default:
-ansi-alias
Programs adhere to Fortran Standard type aliasability rules.
Description:

This option tells the compiler to assume that the program adheres to type aliasability rules defined in the Fortran Standard.

For example, an object of type real cannot be accessed as an integer. For information on the rules for data types and data type constants, see "Data Types, Constants, and Variables" in the Language Reference.

This option directs the compiler to assume the following:

*
Arrays are not accessed out of arrays[aq] bounds.
*
Pointers are not cast to non-pointer types and vice-versa.
*
References to objects of two different scalar types cannot alias. For example, an object of type integer cannot alias with an object of type real or an object of type real cannot alias with an object of type double precision.

If your program adheres to the Fortran Standard type aliasability rules, this option enables the compiler to optimize more aggressively. If it doesn[aq]t adhere to these rules, then you should disable the option with -no-ansi-alias (Linux* OS and OS X*) or /Qansi-alias- (Windows* OS) so the compiler does not generate incorrect code.

Alternate Options:

None

-assume keyword[, keyword...]
Tells the compiler to make certain
assumptions.
Arguments:
keyword
Specifies the assumptions to be made. Possible values are:
none
Disables all assume options.
[no]bscc
Determines whether the backslash character is treated as a C-style control character syntax in character literals.
[no]buffered_io
Determines whether data is immediately read from or written to disk or accumulated in a buffer. For variable length, unformatted files, determines whether data is buffered on input or read directly from disk to user variables.
[no]buffered_stdout
Determines whether data is immediately written to the standard output device or accumulated in a buffer.
[no]byterecl
Determines whether units for the OPEN statement RECL specifier (record length) value in unformatted files are in bytes or longwords (four-byte units).
[no]cc_omp
Determines whether conditional compilation as defined by the OpenMP Fortran API is enabled or disabled.
[no]dummy_aliases
Determines whether the compiler assumes that dummy arguments to procedures share memory locations with other dummy arguments or with COMMON variables that are assigned.
[no]fpe_summary
Determines whether a floating-point exceptions summary is displayed when a STOP statement is encountered.
[no]ieee_fpe_flags
Determines whether the floating-point exception and status flags are saved on routine entry and restored on routine exit.
[no]minus0
Determines whether the compiler uses Fortran 2003 or Fortran 90/77 standard semantics in the SIGN intrinsic when treating -0.0 and +0.0 as 0.0, and how it writes the value on formatted output.
[no]old_boz
Determines whether the binary, octal, and hexadecimal constant arguments in intrinsic functions INT, REAL, DBLE, and CMPLX are treated as signed integer constants.
[no]old_ldout_format
Determines the output of integer and real values in list-directed and namelist-directed output.
[no]old_logical_ldio
Determines whether NAMELIST and list-directed input accept logical values for numeric IO-list items and numeric values for logical IO-list items.
[no]old_maxminloc
Determines the results of intrinsics MAXLOC and MINLOC when given an empty array as an argument.
[no]old_unit_star
Determines whether unit * is treated the same as units 5 and 6, or is distinct.
[no]old_xor
Determines whether .XOR. is defined by the compiler as an intrinsic operator.
[no]protect_allocates
Determines whether memory allocation requests using the ALLOCATE statement are protected with critical sections to avoid random timing problems in a multi-threaded environment.
[no]protect_constants
Determines whether a constant actual argument or a copy of it is passed to a called routine.
[no]protect_parens
Determines whether the optimizer honors parentheses in REAL and COMPLEX expression evaluations by not reassociating operations.
[no]realloc_lhs
Determines whether allocatable objects on the left-hand side of an assignment are treated according to Fortran 2003 rules or earlier Standard Fortran rules.
[no]source_include
Determines whether the compiler searches for USE modules and INCLUDE files in the default directory or in the directory where the source file is located.
[no]std_intent_in
Determines whether the compiler assumes that dummy arguments with the INTENT(IN) attribute in a called procedure are not modified across a call, in accordance with the Fortran standard.
[no]std_minus0_rounding
Determines whether to display a negative value that is not zero but rounds to zero on output with a leading minus sign.
[no]std_mod_proc_name
Determines whether the names of module procedures are allowed to conflict with user external symbol names.
[no]std_value
Determines whether the VALUE attribute has the effect as if the actual argument is assigned to a temporary, and the temporary is then passed to the called procedure so that subsequent changes to the value of the dummy argument do not affect the actual argument, in accordance with the Fortran standard.
[no]underscore
Determines whether the compiler appends an underscore character to external user-defined names.
[no]2underscores (Linux and OS X)
Determines whether the compiler appends two underscore characters to external user-defined names.
[no]writeable-strings
Determines whether character constants go into non-read-only memory.
Default:
nobscc
The backslash character is treated as a normal character in character literals.
nobuffered_io
Data in the internal buffer is immediately read from or written (flushed) to disk (OPEN specifier BUFFERED=[aq]NO[aq]). Data read from variable length, unformatted files is read directly from disk to a user[aq]s variables.
If you set the FORT_BUFFERED environment variable to true, the default is assume buffered_io.
nobuffered_stdout
Data is not buffered for the standard output device but instead is written immediately to the device.
nobyterecl
Units for OPEN statement RECL values with unformatted files are in four-byte (longword) units.
nocc_omp
Conditional compilation as defined by the OpenMP Fortran API is disabled unless option [q or Q]openmp is specified.
If compiler option [q or Q]openmp is specified, the default is assume cc_omp.
nodummy_aliases
Dummy arguments to procedures do not share memory locations with other dummy arguments or with variables shared through use association, host association, or common block use.
nofpe_summary
Suppresses a summary of floating-point exceptions from being displayed when a STOP statement is encountered.
noieee_fpe_flags
The flags are not saved on routine entry and they are not restored on routine exit.
nominus0
The compiler uses Fortran 90/77 standard semantics in the SIGN intrinsic to treat -0.0 and +0.0 as 0.0, and writes a value of 0.0 with no sign on formatted output.
noold_boz
The binary, octal, and hexadecimal constant arguments in intrinsic functions INT, REAL, DBLE, and CMPLX are treated as bit strings that represent a value of the data type of the intrinsic, that is, the bits are not converted.
old_ldout_format
For list-directed and namelist-directed output, integers are written with a fixed width that is dependent on the integer kind, and zero real values are written using the E format.
noold_logical_ldio
Tells the compiler that NAMELIST and list-directed input cannot accept logical values (T, F, etc.) for numeric (integer, real, and complex) IO-list items or numeric values for logical IO-list items. If this option is specified and a logical value is given for a numeric item or a numeric value is given for a logical item in NAMELIST and list-directed input, a run-time error will be produced.
old_maxminloc
MAXLOC and MINLOC return 1 when given an empty array as an argument.
old_unit_star
The READs or WRITEs to UNIT=* go to stdin or stdout, respectively, even if UNIT=5 or 6 has been connected to another file.
old_xor
Intrinsic operator .XOR. is defined by the compiler.
noprotect_allocates
Memory allocation requests using the ALLOCATE statement are not protected with critical sections and may encounter random timing problems in a multi-threaded environment.
protect_constants
A constant actual argument is passed to a called routine. Any attempt to modify it results in an error.
noprotect_parens
The optimizer reorders REAL and COMPLEX expressions without regard for parentheses by reassociating operations if it produces faster executing code.
norealloc_lhs
The compiler uses Standard Fortran rules when interpreting assignment statements. The left-hand side is assumed to be allocated with the correct shape to hold the right-hand side. If it is not, incorrect behavior will occur.
source_include
The compiler searches for USE modules and INCLUDE files in the directory where the source file is located.
std_intent_in
The compiler assumes that dummy arguments with the INTENT(IN) attribute in a called procedure are not modified across a call, in accordance with the Fortran standard.
std_minus0_rounding
A negative value that is not zero but rounds to zero on output is displayed with a leading minus sign. For example, the value -0.00000001 in F5.1 format will be displayed as -0.0 rather than as 0.0.
nostd_mod_proc_name
The compiler allows the names of module procedures to conflict with user external symbol names.
std_value
The compiler assumes that the VALUE attribute has the effect as if the actual argument is assigned to a temporary, and the temporary is then passed to the called procedure so that subsequent changes to the value of the dummy argument do not affect the actual argument, in accordance with the Fortran standard.
Windows:
nounderscore Linux and OS X: underscore On Windows* systems, the compiler does not append an underscore character to external user-defined names. On Linux* and OS X* systems, the compiler appends an underscore character to external user-defined names.
no2underscores (Linux and OS X)
The compiler does not append two underscore characters to external user-defined names that contain an embedded underscore.
nowriteable-strings
The compiler puts character constants into read-only memory.
Description:

This option specifies assumptions to be made by the compiler.

Option
Description
assume none
Disables all the assume options.
assume bscc
Tells the compiler to treat the backslash character () as a C-style control (escape) character syntax in character literals. The "bscc" keyword means "BackSlashControlCharacters."
assume buffered_io
Tells the compiler to accumulate records in a buffer. This sets the default for opening sequential files to BUFFERED=[aq]YES[aq], which also occurs if the FORT_BUFFERED run-time environment variable is specified.
When this option is specified, the internal
buffer is filled, possibly by many record input statements (READ) or output statements (WRITE), before it is read from disk, or written to disk, by the Fortran run-time system. If a file is opened for direct access, I/O buffering is ignored.
Using buffered reads and writes usually makes
disk I/O more efficient by handling larger blocks of data on disk less often. However, if you request buffered writes, records not yet written to disk may be lost in the event of a system failure.
The OPEN statement BUFFERED specifier applies
to a specific logical unit. In contrast, the assume [no]buffered_io option and the FORT_BUFFERED environment variable apply to all Fortran units.
assume buffered_stdout
Tells the Fortran run-time system to accumulate data for the standard output device in a buffer. When the buffer is full or the uses executes a FLUSH on OUTPUT_UNIT in intrinsic module ISO_FORTRAN_ENV, the data is displayed on the standard output unit.
Using buffered writes may be a more efficient
in time and space but use assume nobuffered_stdout if you want data displayed immediately on the standard output device, like for an input prompt.
assume [no]buffered_stdout does not affect and is
not affected by assume [no]buffered_io.
After compiling with this option, the default
blocksize for stdout is 8 KB.
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 value is always in bytes.
If a file is open for unformatted data and
assume byterecl is specified, INQUIRE returns RECL in bytes; otherwise, it returns RECL in longwords. An INQUIRE returns RECL in bytes if the unit is not open.
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.
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.
Specify the option when you compile the called
subprogram. The program semantics involved with dummy aliasing do not strictly obey Standard Fortran and they slow performance, so you get better run-time performance if you do not use this option.
However, if a program depends on dummy aliasing
and you do not specify this option, the run-time behavior of the program will be unpredictable. In such programs, the results will depend on the exact optimizations that are performed. In some cases, normal results will occur, but in other cases, results will differ because the values used in computations involving the offending aliases will differ.
assume fpe_summary
Causes a summary of floating-point exceptions that occurred during program execution to be displayed when a STOP statement is encountered. Counts will be shown for each exception. This is the behavior specified by the Fortran 2003 standard.
Note that if there is no STOP statement, no
summary is displayed.
assume ieee_fpe_flags
Tells the compiler to save floating-point exception and status flags on routine entry and restore them on routine exit.
This option can slow runtime performance
because it provides extra code to save and restore the floating-point exception and status flags (and the rounding mode) on entry to and exit from every routine compiled with the option.
This option can be used to get the full
Fortran Standard behavior of intrinsic modules IEEE EXCEPTIONS, IEEE ARITHMETIC, and IEEE FEATURES, which require that if a flag is signaling on routine entry, the processor will set it to quiet on entry and restore it to signaling on return. If a flag signals while the routine is executing, it will not be set to quiet on routine exit.
Options
fpe and fpe-all can be used to set the initial state for which floating-point exceptions will signal.
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.
assume old_boz
Tells the compiler that the binary, octal, and hexadecimal constant arguments in intrinsic functions INT, REAL, DBLE, and CMPLX should be treated as signed integer constants.
assume noold_ldout_format
Tells the compiler to use Fortran 2003 standard semantics for output of integer and real values in list-directed and namelist-directed output.
Integers are written using an I0 format with a leading blank for
spacing.
Real and complex values are written using and E or F format with
a leading blank for spacing. The format used depends on the magnitude of the value. Values that are zero are written using an F format.
assume old_logical_ldio
Logical values are allowed for numeric items and numeric values are allowed for logical items.
assume noold_maxminloc
Tells the compiler that MAXLOC and MINLOC should return 0 when given an empty array as an argument. Compared to the default setting (old_maxminloc), this behavior may slow performance because of the extra code needed to check for an empty array argument.
assume noold_unit_star
Tells the compiler that READs or WRITEs to UNIT=* go to the file to which UNIT=5 or 6 is connected.
assume noold_xor
Prevents the compiler from defining .XOR. as an intrinsic operator. This lets you use .XOR. as a user-defined operator. This is a Fortran 2003 feature.
assume protect_allocates
Memory allocation requests using the ALLOCATE statement are protected with critical sections to avoid random timing problems in a multi-threaded environment in some distributions and configurations.
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.
assume protect_parens
Tells the optimizer to honor parentheses in REAL and COMPLEX expression evaluations by not reassociating operations. For example, (A+B)+C would not be evaluated as A+(B+C).
If assume noprotect_parens is specified,
(A+B)+C would be treated the same as A+B+C and could be evaluated as A+(B+C) if it produced faster executing code.
Such reassociation could produce different
results depending on the sizes and precision of the arguments.
For example, in (A+B)+C, if B and C had
opposite signs and were very large in magnitude compared to A, A+B could result in the value as B; adding C would result in 0.0. With reassociation, B+C would be 0.0; adding A would result in a non-zero value.
assume realloc_lhs
Tells the compiler that when the left-hand side of an assignment is an allocatable object, it should be reallocated to the shape of the right-hand side of the assignment before the assignment occurs. This is the Fortran 2003 definition. This feature may cause extra overhead at run time.
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. This option affects fpp preprocessor behavior and the USE statement.
assume nostd_intent_in
Tells the compiler to assume that dummy arguments with the INTENT(IN) attribute in a called procedure may be modified across a call. This is not in accordance with the Fortran standard.
If you specify option
standard_semantics, it sets option assume std_intent_in.
assume nostd_minus0_rounding
Tells the compiler to use pre-Fortran 2008 standard semantics for the treatment of IEEE* floating values that are negative, non-zero, and when rounded for display are zero. The value should be printed without a leading minus sign.
For example, the floating value -0.00000001
when rounded in F5.1 format will be displayed as 0.0. Use assume std_minus0_rounding to use Fortran 2008 standard semantics to display this value as -0.0 when rounded in F5.1 format.
assume [no]std_minus0_rounding does not affect
and is not affected by assume [no]minus0. The former controls printing of a minus sign for non-zero numbers while the latter controls printing of actual signed zero values.
assume std_mod_proc_name
Tells the compiler to revise the names of module procedures so they do not conflict with user external symbol names. For example, procedure proc in module m would be named m_MP_proc. The Fortran 2003 Standard requires that module procedure names not conflict with other external symbols.
By default, procedure
proc in module m would be named m_mp_proc, which could conflict with a user-defined external name m_mp_proc.
assume nostd_value
Tells the compiler to use pre-Fortran 2003 standard semantics for the VALUE attribute so that the value of the actual argument is passed to the called procedure, not the address of the actual argument nor the address of a copy of the actual argument.
assume underscore
Tells the compiler 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.
assume 2underscores (Linux and OS X)
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.
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. For example, if you specify assume 2underscores for external names my_program and myprogram, my_program becomes my_program__, but myprogram becomes myprogram_.
assume writeable-strings
Tells the compiler to put character constants into non-read-only memory.
Alternate Options:
assume nobscc
Linux and OS X: -nbs
assume
dummy_aliases Linux and OS X: -common-args
assume
protect_parens Linux and OS X: -fprotect-parens
-auto-scalar
Causes scalar variables of intrinsic types INTEGER, REAL, COMPLEX, and LOGICAL that do not have the SAVE attribute to be allocated to the run-time stack.
Arguments:

None

Default:
-auto-scalar
Scalar variables of intrinsic types INTEGER, REAL, COMPLEX, and LOGICAL that do not have the SAVE attribute are allocated to the run-time stack. Note that the default changes to auto if one of the following options are specified:
*
recursive
*
[q or Q]openmp
Description:

This option causes allocation of scalar variables of intrinsic types INTEGER, REAL, COMPLEX, and LOGICAL to the run-time stack. It is as if they were declared with the AUTOMATIC attribute.

It does not affect variables that have the SAVE attribute (which include initialized locals) or that appear in an EQUIVALENCE statement or in a common block.

This option may provide a performance gain for your program, but if your program depends on variables having the same value as the last time the routine was invoked, your program may not function properly. Variables that need to retain their values across subroutine calls should appear in a SAVE statement.

You cannot specify option save or auto with this option.

NOTE: On Windows NT* systems, there is a performance penalty for addressing a stack frame that is too large. This penalty may be incurred with [Q]auto because arrays are allocated on the stack along with scalars. However, with /Qauto-scalar, you would have to have more than 32K bytes of local scalar variables before you incurred the performance penalty. /Qauto-scalar enables the compiler to make better choices about which variables should be kept in registers during program execution.

Alternate Options:

None

-axcode
Tells the compiler to generate multiple,
feature-specific auto-dispatch code paths for Intel(R) processors if there is a performance benefit.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
code
Indicates to the compiler a feature set that it may target, including which instruction sets it may generate. The following descriptions refer to Intel(R) Streaming SIMD Extensions (Intel(R) SSE) and Supplemental Streaming SIMD Extensions (SSSE). Possible values are:
COMMON-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, as well as the instructions enabled with CORE-AVX2.
MIC-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, Intel(R) AVX-512 Exponential and Reciprocal instructions, Intel(R) AVX-512 Prefetch instructions for Intel(R) processors, and the instructions enabled with CORE-AVX2.
CORE-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, Intel(R) AVX-512 Doubleword and Quadword instructions, Intel(R) AVX-512 Byte and Word instructions and Intel(R) AVX-512 Vector Length extensions, as well as the instructions enabled with CORE-AVX2.
CORE-AVX2
May generate Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.
CORE-AVX-I
May generate the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.
AVX
May generate Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.
SSE4.2
May generate Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel processors.
SSE4.1
May generate Intel(R) SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors.
SSSE3
May generate SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. For OS X* systems, this value is only supported on Intel(R) 64 architecture. This replaces value T, which is deprecated.
SSE3
May generate Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. For OS X* systems, this value is only supported on IA-32 architecture.
SSE2
May generate Intel(R) SSE2 and SSE instructions for Intel(R) processors. This value is not available on OS X* systems.
Default:
OFF
No auto-dispatch code is generated. Feature-specific code is generated and is controlled by the setting of the following compiler options:
*
Linux* OS: -m and -x
*
OS X*: -x
Description:

This option tells the compiler to generate multiple, feature-specific auto-dispatch code paths for Intel(R) processors if there is a performance benefit. It also generates a baseline code path. The Intel feature-specific auto-dispatch path is usually more optimized than the baseline path. Other options, such as O3, control how much optimization is performed on the baseline path.

The baseline code path is determined by the architecture specified by options -m or -x (Linux* OS and OS X*) or options /arch or /Qx (Windows* OS). While there are defaults for the [Q]x option that depend on the operating system being used, you can specify an architecture and optimization level for the baseline code that is higher or lower than the default. The specified architecture becomes the effective minimum architecture for the baseline code path.

If you specify both the [Q]ax and [Q]x options, the baseline code will only execute on Intel(R) processors compatible with the setting specified for the [Q]x.

If you specify both the -ax and -m options (Linux OS and OS X) or the /Qax and /arch options (Windows OS), the baseline code will execute on non-Intel processors compatible with the setting specified for the -m or /arch option.

If you specify both the -ax and -march options (Linux OS and OS X), or the /Qax and /arch options (Windows OS), the compiler will not generate Intel-specific instructions.

The [Q]ax option tells the compiler to find opportunities to generate separate versions of functions that take advantage of features of the specified instruction features.

If the compiler finds such an opportunity, it first checks whether generating a feature-specific version of a function is likely to result in a performance gain. If this is the case, the compiler generates both a feature-specific version of a function and a baseline version of the function. At run time, one of the versions is chosen to execute, depending on the Intel(R) processor in use. In this way, the program can benefit from performance gains on more advanced Intel processors, while still working properly on older processors and non-Intel processors. A non-Intel processor always executes the baseline code path.

You can use more than one of the feature values by combining them. For example, you can specify -axSSE4.1,SSSE3 (Linux OS and OS X) or /QaxSSE4.1,SSSE3 (Windows OS). You cannot combine the old style, deprecated options and the new options. For example, you cannot specify -axSSE4.1,T (Linux OS and OS X) or /QaxSSE4.1,T (Windows OS).

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-Bdir
Specifies a directory that can be used to find include files, libraries, and executables.
Arguments:
dir
Is the directory to be used. If necessary, the compiler adds a directory separator character at the end of dir.
Default:
OFF
The compiler looks for files in the directories specified in your PATH environment variable.
Description:

This option 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.

Alternate Options:

None

-Bdynamic (L*X only)
Enables dynamic linking of libraries at run time.
Arguments:

None

Default:
OFF
Limited dynamic linking occurs.
Description:

This option enables dynamic linking of libraries at run time. Smaller executables are created than with static linking.

This option is placed in the linker command line corresponding to its location on the user command line. It controls the linking behavior of any library that is passed using the command line.

All libraries on the command line following option -Bdynamic are linked dynamically until the end of the command line or until a -Bstatic option is encountered. The -Bstatic option enables static linking of libraries.

Alternate Options:

None

-Bstatic (L*X only)
Enables static linking of a user[aq]s library.
Arguments:

None

Default:
OFF
Default static linking occurs.
Description:

This option enables static linking of a user[aq]s library.

This option is placed in the linker command line corresponding to its location on the user command line. It controls the linking behavior of any library that is passed using the command line.

All libraries on the command line following option -Bstatic are linked statically until the end of the command line or until a -Bdynamic option is encountered. The -Bdynamic option enables dynamic linking of libraries.

Alternate Options:

None

-Bsymbolic (L*X only)
Binds references to all global symbols in a program to the definitions within a user[aq]s shared library.
Arguments:

None

Default:
OFF
When a program is linked to a shared library, it can override the definition within the shared library.
Description:

This option binds references to all global symbols in a program to the definitions within a user[aq]s shared library.

This option is only meaningful on Executable Linkage Format (ELF) platforms that support shared libraries.

CAUTION: This option can have unintended side-effects of disabling symbol preemption in the shared library.

Alternate Options:

None

-Bsymbolic-functions (L*X only)
Binds references to all global function symbols in a program to the definitions within a user[aq]s shared library.
Arguments:

None

Default:
OFF
When a program is linked to a shared library, it can override the definition within the shared library.
Description:

This option binds references to all global function symbols in a program to the definitions within a user[aq]s shared library.

This option is only meaningful on Executable Linkage Format (ELF) platforms that support shared libraries.

CAUTION: This option can have unintended side-effects of disabling symbol preemption in the shared library.

Alternate Options:

None

-c
Prevents linking.
Arguments:

None

Default:
OFF
Linking is performed.
Description:

This option prevents linking. Compilation stops after the object file is generated.

The compiler generates an object file for each Fortran source file.

Alternate Options:

Linux and OS X: None

Windows: /compile-only, /nolink

-ccdefault keyword
Specifies the type of carriage control used when a file is displayed at a terminal screen.
Arguments:
keyword
Specifies the carriage-control setting to use. Possible values are:
none
Tells the compiler to use no carriage control processing.
default
Tells the compiler to use the default carriage-control setting.
fortran
Tells the compiler to use normal Fortran interpretation of the first character. For example, the character 0 causes output of a blank line before a record.
list
Tells the compiler to output one line feed between records.
Default:
ccdefault default
The compiler uses the default carriage control setting.
Description:

This option specifies the type of carriage control used when a file is displayed at a terminal screen (units 6 and *). It provides the same functionality as using the CARRIAGECONTROL specifier in an OPEN statement.

The default carriage-control setting can be affected by the vms option. If option vms is specified with ccdefault default, carriage control defaults to normal Fortran interpretation (ccdefault fortran) if the file is formatted and the unit is connected to a terminal. If option novms (the default) is specified with ccdefault default, carriage control defaults to list (ccdefault list).

Alternate Options:

None

-check [keyword[, keyword...]]
-nocheck
Checks for certain conditions at run time.
Arguments:
keyword
Specifies the conditions to check. Possible values are:
none
Disables all check options.
[no]arg_temp_created
Determines whether checking occurs for actual arguments before routine calls.
[no]assume
Determines whether checking occurs to test that the scalar-Boolean-expression in the ASSUME directive is true, or that the addresses in the ASSUME_ALIGNED directive are aligned on the specified byte boundaries.
[no]bounds
Determines whether checking occurs for array subscript and character substring expressions.
[no]format
Determines whether checking occurs for the data type of an item being formatted for output.
[no]output_conversion
Determines whether checking occurs for the fit of data items within a designated format descriptor field.
[no]pointers
Determines whether checking occurs for certain disassociated or uninitialized pointers or unallocated allocatable objects.
[no]stack
Determines whether checking occurs on the stack frame.
[no]uninit
Determines whether checking occurs for uninitialized variables.
all
Enables all check options.
Default:
nocheck
No checking is performed for run-time failures. Note that if option vms is specified, the defaults are check format and check output_conversion.
Description:

This option checks for certain conditions at run time.

Option
Description
check none
Disables all check options (same as nocheck).
check arg_temp_created
Enables run-time checking on whether actual arguments are copied into temporary storage before routine calls. If a copy is made at run-time, an informative message is displayed.
check assume
Enables run-time checking on whether the scalar-Boolean-expression in the ASSUME directive is true and that the addresses in the ASSUME_ALIGNED directive are aligned on the specified byte boundaries. If the test is .FALSE., a run-time error is reported and the execution terminates.
check bounds
Enables compile-time and run-time checking for array subscript and character substring expressions. An error is reported if the expression is outside the dimension of the array or the length of the string.
For array bounds, each individual dimension is checked. For arrays that are dummy arguments, only the lower bound is checked for a dimension whose upper bound is specified as * or where the upper and lower bounds are both 1.
For some intrinsics that specify a DIM=
dimension argument, such as LBOUND, an error is reported if the specified dimension is outside the declared rank of the array being operated upon.
Once the program is debugged, omit this option to reduce executable program size and slightly improve run-time performance.
It is recommended that you do bounds checking on unoptimized code. If you use option check bounds on optimized code, it may produce misleading messages because registers (not memory locations) are used for bounds values.
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).
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 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 without loss of significant digits. Format truncation occurs, the field is filled with asterisks (*), and execution continues.
check pointers
Enables run-time checking for disassociated or uninitialized Fortran pointers, unallocated allocatable objects, and integer pointers that are uninitialized.
check stack
Enables checking on the stack frame. The stack is checked for buffer overruns and buffer underruns. This option also enforces local variables initialization and stack pointer verification.
This option disables optimization and overrides any optimization level set by option O.
check uninit
Enables run-time checking for uninitialized variables. If a variable is read before it is written, a run-time error routine will be called. Only local scalar variables of intrinsic type INTEGER, REAL, COMPLEX, and LOGICAL without the SAVE attribute are checked.
check all
Enables all check options. This is the same as specifying check with no keyword.
This option disables optimization and overrides any optimization level set by option O.

To get more detailed location information about where an error occurred, use option traceback.

Alternate Options:
check none
Linux and OS X: -nocheck
check bounds
Linux and OS X: -CB
check uninit
Linux and OS X: -CU
check all
Linux and OS X: -check, -C
-coarray[=keyword] (L*X only)
Enables the coarray feature.
Arguments:
keyword
Specifies the memory system where the coarrays will be implemented. Possible values are:
shared
Indicates a shared memory system. This is the default.
distributed
Indicates a distributed memory system.
coprocessor
Indicates a configuration where image 1 is running on the host processor, and other images are run on host processors or Intel(R) MIC Architecture coprocessors. The configuration file is used to determine where the images will be run; that is, how many on the host processors and how many on the coprocessors. This results in an executable containing code that will replicate itself NUM_IMAGES() more times, ultimately resulting in NUM_IMAGES()+1 running images. This setting is only available on Linux* OS on Intel(R) 64 architecture.
This setting requires that option -coarray-config-file also be specified.
single
Indicates a configuration where the image does not contain self-replication code. This results in an executable with a single running image. This configuration can be useful for debugging purposes, even though there are no inter-image interactions.
Default:
OFF
Coarrays are not enabled without specifying this option.
Description:

This option enables the coarray feature of the Fortran 2008 Standard. It enables any coarray syntax in your program. If this option is not specified, coarray syntax is rejected.

It also tells the driver to link against appropriate libraries, and to create the appropriate executables.

Only one keyword can be in effect. If you specify more than one keyword, the last one specified takes precedence. However, if keyword single is specified anywhere on the command line, it takes precedence.

On Intel(R) MIC Architecture, this option is only available on Linux* OS.

You can specify option [Q]coarray-num-images to specify the default number of images that can be used to run a coarray executable. If you do not specify that option, you get the number of execution units on the current system.

You can specify the [Q]coarray-config-file option to specify the name of a Message Passing Interface (MPI) configuration file.

Options [Q]coarray-num-images and [Q]coarray-config-file are valid for all keyword values.

Alternate Options:

None

-coarray-config-file=filename (L*X only)
Specifies the name of a Message Passing Interface (MPI) configuration file.
Arguments:

filename
Is the name of the MPI configuration file. You can specify a path.
Default:
OFF
When coarrays are enabled, the compiler uses default settings for MPI.
Description:

This option specifies the name of a Message Passing Interface (MPI) configuration file. This file is used by the compiler when coarrays are processed; it configures the MPI for multi-node operations.

On Intel(R) MIC Architecture, this option is only available on Linux* OS.

This option has no affect unless you also specify the [Q]coarray option, which is required to create the coarray executable.

Note that when a setting is specified in environment variable FOR_COARRAY_CONFIG_FILE, it overrides the compiler option setting.

Alternate Options:

None

-coarray-num-images=n (L*X only)
Specifies the default number of images that can be used to run a coarray executable.
Arguments:

n
Is the default number of images. The limit is determined from the system configuration.
Default:
OFF
The number of images is determined at run-time.
Description:

This option specifies the default number of images that can be used to run a coarray executable.

On Intel(R) MIC Architecture, this option is only available on Linux* OS.

This option has no affect unless you also specify the [Q]coarray option. This option is required to create the coarray executable.

You can specify option [Q]coarray-num-images to specify the default number of images that can be used to run a coarray executable. If you do not specify that option, you get the number of execution units on the current system.

Note that when a setting is specified in environment variable FOR_COARRAY_NUM_IMAGES, it overrides the compiler option setting.

Alternate Options:

None

-complex-limited-range
-no-complex-limited-range
Determines whether the use of basic algebraic expansions of some arithmetic operations involving data of type COMPLEX is enabled.
Arguments:

None

Default:
-no-complex-limited-range
Basic algebraic expansions of some arithmetic operations involving data of type COMPLEX are disabled.
Description:

This option determines whether the use of basic algebraic expansions of some arithmetic operations involving data of type COMPLEX is enabled.

When the option is enabled, this can cause performance improvements in programs that use a lot of COMPLEX arithmetic. However, values at the extremes of the exponent range may not compute correctly.

Alternate Options:

None

-convert keyword
Specifies the format of unformatted files containing numeric data.
Arguments:
keyword
Specifies the format for the unformatted numeric data. Possible values are:
native
Specifies that unformatted data should not be converted.
big_endian
Specifies that the format will be big endian for integer data and big endian IEEE floating-point for real and complex data.
cray
Specifies that the format will be big endian for integer data and CRAY* floating-point for real and complex data.
fdx (Linux* OS, OS X*)
Specifies that the format will be little endian for integer data, and VAX processor floating-point format F_floating, D_floating, and X_floating for real and complex data.
fgx (Linux OS, OS X)
Specifies that the format will be little endian for integer data, and VAX processor floating-point format F_floating, G_floating, and X_floating for real and complex data.
ibm
Specifies that the format will be big endian for integer data and IBM* System370 floating-point format for real and complex data.
little_endian
Specifies that the format will be little endian for integer data and little endian IEEE floating-point for real and complex data.
vaxd
Specifies that the format will be little endian for integer data, and VAX* processor floating-point format F_floating, D_floating, and H_floating for real and complex data.
vaxg
Specifies that the format will be little endian for integer data, and VAX processor floating-point format F_floating, G_floating, and H_floating for real and complex data.
Default:
convert native
No conversion is performed on unformatted files containing numeric data.
Description:

This option specifies the format of unformatted files containing numeric data.

Option
Description
convert native
Specifies that unformatted data should not be converted.
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* System370 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 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.

Non-native data conversion works on scalars and arrays of intrinsic types: INTEGER*1, INTEGER*2, INTEGER*4, INTEGER*8, including LOGICAL*1, LOGICAL*2, LOGICAL*4, LOGICAL*8, and REAL*4, REAL*8, REAL*16, including COMPLEX*8, COMPLEX*16, and COMPLEX*32. Conversion does not work inside defined type records on their individual fields. For example:

type REC integer(8) :: K real(8) :: X end type REC type (REC) :: R write (17) R%K, R%X ! conversion will work on these objects write (17) R ! conversion will not work on the fields of this object

Alternate Options:

None

-cxxlib
-no-cxxlib
Determines whether the compiler links using the C++ run-time libraries provided by gcc.
Arguments:

None

Default:
-no-cxxlib
The compiler uses the default run-time libraries and does not link to any additional C++ run-time libraries.
Description:

This option determines whether the compiler links to the standard C++ run-time library (libstdc++). It is useful for building mixed Fortran/C++ applications.

Alternate Options:

None

-Dname[=value]
Defines a symbol name that can be associated with an optional value.
Arguments:
name
Is the name of the symbol.
value
Is an optional integer or an optional character string delimited by double quotes; for example, Dname=string.
Default:
noD
Only default symbols or macros are defined.
Description:

Defines a symbol name that can be associated with an optional value. This definition is used during preprocessing.

If a value is not specified, name  is defined as "1".

If you want to specify more than one definition, you must use separate D options.

If you specify noD, all preprocessor definitions apply only to fpp and not to Intel(R) Fortran conditional compilation directives. To use this option, you must also specify the fpp option.

CAUTION: On Linux* and OS X* systems, if you are not specifying a value, do not use D for name, because it will conflict with the -DD option.

Alternate Options:
D
Linux and OS X: None Windows: /define:name[=value]
noD
Linux and OS X: -nodefine Windows: /nodefine
-debug [keyword]
Enables or disables generation of debugging information.
Arguments:
keyword
Is the type of debugging information to be generated. Possible values are:
none
Disables generation of debugging information.
full or all
Generates complete debugging information.
minimal
Generates line number information for debugging.
[no]emit_column
Determines whether the compiler generates column number information for debugging.
[no]inline-debug-info
Determines whether the compiler generates enhanced debug information for inlined code.
[no]pubnames
Determines whether the compiler generates a DWARF debug_pubnames section.
[no]semantic-stepping
Determines whether the compiler generates enhanced debug information useful for breakpoints and stepping.
[no]variable-locations
Determines whether the compiler generates enhanced debug information useful in finding scalar local variables.
extended
Sets keyword values semantic-stepping and variable-locations.
[no]parallel (Linux only)
Determines whether the compiler generates parallel debug code instrumentations useful for thread data sharing and reentrant call detection.

For information on the non-default settings for these keywords, see the Description section.

Default:
varies
Normally, the default is -debug none and no debugging information is generated. However, on Linux* OS, the -debug inline-debug-info option will be enabled by default if you compile with optimizations (option -O2 or higher) and debugging is enabled (option -g).
Description:

This option enables or disables generation of debugging information.

Note that if you turn debugging on, optimization is turned off.

Keywords semantic-stepping, inline-debug-info, variable-locations, and extended can be used in combination with each other. If conflicting keywords are used in combination, the last one specified on the command line has precedence.

Option
Description
-debug none
Disables generation of debugging information.
-debug full or -debug all
Generates complete debugging information. It is the same as specifying -debug with no keyword.
-debug minimal
Generates line number information for debugging.
-debug emit_column
Generates column number information for debugging.
-debug inline-debug-info
Generates enhanced debug information for inlined code.
On inlined functions, symbols are (by default) associated with the caller. This option causes symbols for inlined functions to be associated with the source of the called function.
-debug pubnames
The compiler generates a DWARF debug_pubnames section. This provides a means to list the names of global objects and functions in a compilation unit.
-debug semantic-stepping
Generates 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.
This option has no impact unless optimizations have also been enabled.
-debug variable-locations
Generates enhanced debug information useful in finding scalar local variables. It uses a feature of the Dwarf object module known as "location lists".
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.
-debug extended
Sets keyword values semantic-stepping and variable-locations. It also tells the compiler to include column numbers in the line information.
-debug parallel
Generates parallel debug code instrumentations needed for the thread data sharing and reentrant call detection. For this setting to be effective, option -qopenmp must be set.

On Linux* systems, debuggers read debug information from executable images. As a result, information is written to object files and then added to the executable by the linker.

On OS X* systems, debuggers read debug information from object files. As a result, the executables don[aq]t contain any debug information. Therefore, if you want to be able to debug on these systems, you must retain the object files.

Alternate Options:
For -debug full, -debug all, or -debug
Linux and OS X: -g
For -debug variable-locations
Linux and OS X: -fvar-tracking
For -debug semantic-stepping
Linux and OS X: -fvar-tracking-assignments
-debug-parameters [keyword]
-nodebug-parameters
Tells the compiler to generate debug information for PARAMETERs used in a program.
Arguments:
keyword
Are the PARAMETERs to generate debug information for. Possible values are:
none
Generates no debug information for any PARAMETERs used in the program. This is the same as specifying nodebug-parameters.
used
Generates debug information for only PARAMETERs that have actually been referenced in the program. This is the default if you do not specify a keyword.
all
Generates debug information for all PARAMETERs defined in the program.
Default:
nodebug-parameters
The compiler generates no debug information for any PARAMETERs used in the program. This is the same as specifying keywordnone.
Description:

This option tells the compiler to generate debug information for PARAMETERs used in a 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 keywordall.

Alternate Options:

None

-diag-type=diag-list
Controls the display of diagnostic information.
Arguments:
type
Is an action to perform on diagnostics. Possible values are:
enable
Enables a diagnostic message or a group of messages. If you specify -diag-enable=all (Linux* OS and OS X*) or /Qdiag-enable:all (Windows* OS), all diagnostic messages shown in diag-list are enabled.
disable
Disables a diagnostic message or a group of messages. If you specify -diag-disable=all (Linux* OS and OS X*) or /Qdiag-disable:all (Windows* OS), all diagnostic messages shown in diag-list are disabled.
error
Tells the compiler to change diagnostics to errors.
warning
Tells the compiler to change diagnostics to warnings.
remark
Tells the compiler to change diagnostics to remarks (comments).
diag-list
Is a diagnostic group or ID value. Possible values are:
driver
Specifies diagnostic messages issued by the compiler driver.
vec
Specifies diagnostic messages issued by the vectorizer.
par
Specifies diagnostic messages issued by the auto-parallelizer (parallel optimizer).
openmp
Specifies diagnostic messages issued by the OpenMP* parallelizer.
warn
Specifies diagnostic messages that have a "warning" severity level.
error
Specifies diagnostic messages that have an "error" severity level.
remark
Specifies diagnostic messages that are remarks or comments.
cpu-dispatch
Specifies the CPU dispatch remarks for diagnostic messages. These remarks are enabled by default.
id[,id,...]
Specifies the ID number of one or more messages. If you specify more than one message number, they must be separated by commas. There can be no intervening white space between each id.
tag[,tag,...]
Specifies the mnemonic name of one or more messages. If you specify more than one mnemonic name, they must be separated by commas. There can be no intervening white space between each tag.
The diagnostic messages generated can be affected by certain options, such as [Q]x, /arch (Windows) or -m (Linux and OS X).
Default:
OFF
The compiler issues certain diagnostic messages by default.
Description:

This option controls the display of diagnostic information. Diagnostic messages are output to stderr unless the [Q]diag-file option is specified.

To control the diagnostic information reported by the vectorizer, use options [q or Q]opt-report and [q or Q]opt-report-phase, phase vec.

To control the diagnostic information reported by the auto-parallelizer, use options [q or Q]opt-report and [q or Q]opt-report-phase, phase par.

Alternate Options:
enable vec
Linux and OS X: -qopt-report; -qopt-report -qopt-report-phase=vec
disable vec
Linux and OS X: -qopt-report=0 -qopt-report-phase=vec
enable par
Linux and OS X: -qopt-report; -qopt-report -qopt-report-phase=par
disable par
Linux and OS X: -qopt-report=0 -qopt-report-phase=par
-diag-dump
Tells the compiler to print all enabled diagnostic messages and stop compilation.
Arguments:

None

Default:
OFF
The compiler issues certain diagnostic messages by default.
Description:

This option tells the compiler to print all enabled diagnostic messages and stop compilation. The diagnostic messages are output to stdout.

This option prints the enabled diagnostics from all possible diagnostics that the compiler can issue, including any default diagnostics.

If diag-list is specified for the [Q]diag-enable option, the print out will include the diag-list diagnostics.

Alternate Options:

None

-diag-enable=sc[n] (L*X only)
-diag-enable=sc-mode (L*X only)
-diag-disable=sc (L*X only)
Enables static analysis diagnostics. You can determine which diagnostics to emit based on severity or you can specify an analysis mode for diagnostic messages. This is a deprecated option. There is no replacement option.
Arguments:
n
Specifies the level of severity to report. Possible values are:
1
Reports only diagnostics with a severity level of "critical". Diagnostics with a severity level of "error" or "warning" are not displayed.
2
Reports all diagnostics with a severity level of "critical" and "error". Diagnostics with a severity level of "warning" are not reported. This is the default.
3
Reports all diagnostics regardless of the severity level.
mode
Specifies the analysis mode. Possible values are:
full
This mode attempts to find all program weaknesses, even at the expense of more false positives. This mode is recommended when using the tool for security assurance.
This is the default if -diag-enable=sc{[1|2|3]} (Linux* OS and OS X*) or /Qdiag-enable:sc{[1|2|3]} (Windows* OS) is present. Otherwise, the default is None (static analysis diagnostics are disabled).
concise
This mode attempts to reduce false positives somewhat more than reducing false negatives. This mode is recommended when using the tool for general error detection.
precise
This mode attempts to avoid all false positives, even at the expense of substantially reduced error checking. This mode is recommended when using the tool for acceptance screening.
Default:
-diag-disable=sc and /Qdiag-disable:sc
Static analysis diagnostics are disabled.
Description:

This option enables static analysis diagnostics.

If you specify n for the option, you can determine which diagnostics to emit based on severity. If you specify mode, you can also specify an analysis mode for diagnostic messages.

To disable static analysis, specify /Qdiag-disable:sc (Windows* OS) or option -diag-disable=sc (Linux* OS).

You can also specify the following options that affect the diagnostics:

*
Option [Q]diag-error setting sc This changes all Static Analysis diagnostics to errors.
*
Option [Q]diag-warning setting sc This changes all Static Analysis diagnostics to warnings.
*
Option [Q]diag-remark setting sc This changes all Static Analysis diagnostics to remarks (comments).

This static analysis feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-diag-enable=sc-enums (L*X only)
Tells static analysis to treat enumeration variables as known values equal to any one of the associated enumeration literals. This is a deprecated option. There is no replacement option.
Arguments:

None

Default:
OFF
If static analysis is enabled, it treats unknown enumeration variables as unknown integer values.
Description:

This option tells static analysis to treat enumeration variables as known values equal to any one of the associated enumeration literals. By default, static analysis treats unknown enumeration variables as unknown integer values. Setting this option may find additional errors but tends to create more false positives.

This option is ignored unless you enable static analysis diagnostics by specifying option [Q]diag-enable setting sc[n] or setting sc-mode.

This static analysis feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-diag-enable=sc-include (L*X only)
Tells a source code analyzer to process include files and source files when issuing diagnostic messages. This is a deprecated option. There is no replacement option.
Arguments:

None

Default:
OFF
The compiler issues certain diagnostic messages by default. If static analysis is enabled, include files are not analyzed by default.
Description:

This option tells the static security analyzer to process include files and source files when issuing diagnostic messages. Normally, when static analysis diagnostics are enabled, only source files are analyzed.

This option is ignored unless you enable static analysis diagnostics by specifying option [Q]diag-enable setting sc[n] or setting sc-mode.

This static analysis feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-diag-enable=sc-single-file (L*X only)
Tells static analysis to process each file individually. This is a deprecated option. There is no replacement option.
Arguments:

None

Default:
OFF
If static analysis is enabled, it analyzes the whole program.
Description:

This option tells static analysis to process each file individually. Skipping the usual whole-program analysis reduces memory requirements and analysis time on large programs but often finds fewer real errors.

This option is ignored unless you enable static analysis diagnostics by specifying option [Q]diag-enable setting sc[n] or setting sc-mode.

This static analysis feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-diag-error-limit=n
-no-diag-error-limit
Specifies the maximum number of errors allowed before compilation stops.
Arguments:
n
Is the maximum number of error-level or fatal-level compiler errors allowed.
Default:
30
A maximum of 30 error-level and fatal-level messages are allowed.
Description:

This option specifies the maximum number of errors allowed before compilation stops. It indicates the maximum number of error-level or fatal-level compiler errors allowed for a file specified on the command line.

If you specify the negative form of the [Q]diag-error-limit option on the command line, there is no limit on the number of errors that are allowed.

If the maximum number of errors is reached, a warning message is issued and the next file (if any) on the command line is compiled.

Alternate Options:

Linux and OS X: -error-limit and -noerror-limit

-diag-file[=filename] (L*X only)
Causes the results of diagnostic analysis to be output to a file.
Arguments:
filename
Is the name of the file for output.
Default:
OFF
Diagnostic messages are output to stderr.
Description:

This option causes the results of diagnostic analysis to be output to a file. The file is placed in the current working directory.

You can include a file extension in filename. For example, if file.txt is specified, the name of the output file is file.txt. If you do not provide a file extension, the name of the file is filename.diag.

If filename is not specified, the name of the file is name-of-the-first-source-file.diag. This is also the name of the file if the name specified for file conflicts with a source file name provided in the command line.

NOTE: If you specify the [Q]diag-file option and you also specify the [Q]diag-file-append option, the last option specified on the command line takes precedence.

Alternate Options:

None

-diag-file-append[=filename] (L*X only)
Causes the results of diagnostic analysis to be appended to a file.
Arguments:
filename
Is the name of the file to be appended to. It can include a path.
Default:
OFF
Diagnostic messages are output to stderr.
Description:

This option causes the results of diagnostic analysis to be appended to a file. If you do not specify a path, the driver will look for filename in the current working directory.

If filename is not found, then a new file with that name is created in the current working directory. If the name specified for file conflicts with a source file name provided in the command line, the name of the file is name-of-the-first-source-file.diag.

NOTE: If you specify the [Q]diag-file-append option and you also specify the [Q]diag-file option, the last option specified on the command line takes precedence.

Alternate Options:

None

-diag-id-numbers
-no-diag-id-numbers
Determines whether the compiler displays diagnostic messages by using their ID number values.
Arguments:

None

Default:
-diag-id-numbers
The compiler displays diagnostic messages by using their ID number values.
Description:

This option determines whether the compiler displays diagnostic messages by using their ID number values. If you specify the negative form of the [Q]diag-id-numbers option, mnemonic names are output for driver diagnostics only.

Alternate Options:

None

-diag-onceid[,id,...]
Tells the compiler to issue one or more diagnostic messages only once.
Arguments:
id
Is the ID number of the diagnostic message. If you specify more than one message number, they must be separated by commas. There can be no intervening white space between each id.
Default:
OFF
The compiler issues certain diagnostic messages by default.
Description:

This option tells the compiler to issue one or more diagnostic messages only once.

Alternate Options:

None

-diag-sc-dir[=dir] (L*X only)
Specifies a directory for static analysis results. This is a deprecated option. There is no replacement option.
Arguments:
dir
Is the name of the directory where the results should be placed.
Default:
OFF
If static analysis is enabled, analysis results are placed in the current working directory. For more details, see below.
Description:

This option specifies a directory for static analysis results.

If you do not specify dir, the results are placed in the current working directory. Results are placed in a subdirectory with the name rnnnsc, where nnn is replaced by the next available sequence number (001, 002, etc.).

This option is ignored unless you enable static analysis diagnostics by specifying option [Q]diag-enable setting sc[n] or setting sc-mode.

Alternate Options:

None

-d-lines
-nod-lines
Compiles debug statements.
Arguments:

None

Default:
nod-lines
Debug lines are treated as comment lines.
Description:

This option compiles debug statements. It specifies that lines in fixed-format files that contain a D in column 1 (debug statements) should be treated as source code.

Alternate Options:

Linux and OS X: -DD

-double-size size
Specifies the default KIND for DOUBLE PRECISION and DOUBLE COMPLEX declarations, constants, functions, and intrinsics.
Arguments:
size
Specifies the default KIND for DOUBLE PRECISION and DOUBLE COMPLEX declarations, constants, functions, and intrinsics. Possible values are: 64 (KIND=8) or 128 (KIND=16).
Default:
64
DOUBLE PRECISION variables are defined as REAL*8 and DOUBLE COMPLEX variables are defined as COMPLEX*16.
Description:

This option defines the default KIND for DOUBLE PRECISION and DOUBLE COMPLEX declarations, constants, functions, and intrinsics.

Option
Description
double-size 64
Defines DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL(KIND=8) (REAL*8) and defines DOUBLE COMPLEX declarations, functions, and intrinsics as COMPLEX(KIND=8) (COMPLEX*16).
double-size 128
Defines DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL(KIND=16) (REAL*16) and defines DOUBLE COMPLEX declarations, functions, and intrinsics as COMPLEX(KIND=16) (COMPLEX*32).

The real-size option overrides the double-size option; for example, on Linux* systems, "-double-size 64 -real-size 128" acts like "-double-size 128 -real-size 128".

Alternate Options:

None

-dryrun
Specifies that driver tool commands should be shown but not executed.
Arguments:

None

Default:
OFF
No tool commands are shown, but they are executed.
Description:

This option specifies that driver tool commands should be shown but not executed.

Alternate Options:

None

-dumpmachine
Displays the target machine and operating system configuration.
Arguments:

None

Default:
OFF
The compiler does not display target machine or operating system information.
Description:

This option displays the target machine and operating system configuration. No compilation is performed.

Alternate Options:

None

-dynamic-linker file (L*X only)
Specifies a dynamic linker other than the default.
Arguments:
file
Is the name of the dynamic linker to be used.
Default:
OFF
The default dynamic linker is used.
Description:

This option lets you specify a dynamic linker other than the default.

Alternate Options:

None

-dynamiclib (M*X only)
Invokes the libtool command to generate dynamic libraries.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
The compiler produces an executable.
Description:

This option invokes the libtool command to generate dynamic libraries.

When passed this option, the compiler uses the libtool command to produce a dynamic library instead of an executable when linking.

To build static libraries, you should specify option -staticlib or libtool -static <objects>.

Alternate Options:

None

-dyncom "common1,common2,..."
Enables dynamic allocation of common blocks at run time.
Arguments:
common1,common2,...
Are the names of the common blocks to be dynamically allocated. The list of names must be within quotes.
Default:
OFF
Common blocks are not dynamically allocated at run time.
Description:

This option enables dynamic allocation of the specified common blocks at run time. For example, to enable dynamic allocation of common blocks a, b, and c at run time, use this syntax:

/Qdyncom "a,b,c" ! on Windows systems

-dyncom "a,b,c" ! on Linux and OS X systems

The following are some limitations that you should be aware of when using this option:

*
An entity in a dynamic common cannot be initialized in a DATA statement.
*
Only named common blocks can be designated as dynamic COMMON.
*
An entity in a dynamic common block must not be used in an EQUIVALENCE expression with an entity in a static common block or a DATA-initialized variable.
Alternate Options:

None

-E
Causes the preprocessor to send output to stdout.
Arguments:

None

Default:
OFF
Preprocessed source files are output to the compiler.
Description:

This option causes the preprocessor to send output to stdout. Compilation stops when the files have been preprocessed.

When you specify this option, the compiler[aq]s preprocessor expands your source module and writes the result to stdout. The preprocessed source contains #line directives, which the compiler uses to determine the source file and line number.

Alternate Options:

None

-EP
Causes the preprocessor to send output to stdout, omitting #line directives.
Arguments:

None

Default:
OFF
Preprocessed source files are output to the compiler.
Description:

This option causes the preprocessor to send output to stdout, omitting #line directives.

If you also specify option preprocess-only, option P, or option F, the preprocessor will write the results (without #line directives) to a file instead of stdout.

Alternate Options:

None

-extend-source [size]
-noextend-source
Specifies the length of the statement field in a fixed-form source file.
Arguments:
size
Is the length of the statement field in a fixed-form source file. Possible values are: 72, 80, or 132.
Default:
72
If you do not specify this option or you specify noextend-source, the statement field ends at column 72.
132
If you specify extend_source without size, the statement field ends at column 132.-
Description:

This option specifies the size (column number) of the statement field of a source line in a fixed-form source file. This option is valid only for fixed-form files; it is ignored for free-form files.

When size is specified, it is the last column parsed as part of the statement field. Any columns after that are treated as comments.

If you do not specify size, it is the same as specifying extend_source 132.

Option
Description
extend-source 72
Specifies that the statement field ends at column 72.
extend-source 80
Specifies that the statement field ends at column 80.
extend-source 132
Specifies that the statement field ends at column 132.
Alternate Options:
extend-source 72
Linux and OS X: -72
extend-source 80
Linux and OS X: -80
extend-source 132
Linux and OS X: -132
-Fdir (M*X only)
Adds a framework directory to the head of an include file search path.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
dir
Is the name for the framework directory.
Default:
OFF
The compiler does not add a framework directory to the head of an include file search path.
Description:

This option adds a framework directory to the head of an include file search path.

Alternate Options:

None

-f66
Tells the compiler to apply FORTRAN 66 semantics.
Arguments:

None

Default:
OFF
The compiler applies Fortran 95 semantics.
Description:

This option tells the compiler to apply FORTRAN 66 semantics when interpreting language features. This causes the following to occur:

*
DO loops are always executed at least once
*
FORTRAN 66 EXTERNAL statement syntax and semantics are allowed
*
If the OPEN statement STATUS specifier is omitted, the default changes to STATUS=[aq]NEW[aq] instead of STATUS=[aq]UNKNOWN[aq]
*
If the OPEN statement BLANK specifier is omitted, the default changes to BLANK=[aq]ZERO[aq] instead of BLANK=[aq]NULL[aq]
Alternate Options:

None

-f77rtl
-nof77rtl
Tells the compiler to use the run-time behavior of FORTRAN 77.
Arguments:

None

Default:
nof77rtl
The compiler uses the run-time behavior of Intel(R) Fortran.
Description:

This option tells the compiler to use the run-time behavior of FORTRAN 77.

Specifying this option controls the following run-time behavior:

*
When the unit is not connected to a file, some INQUIRE specifiers will return different values:
*
NUMBER= returns 0
*
ACCESS= returns [aq]UNKNOWN[aq]
*
BLANK= returns [aq]UNKNOWN[aq]
*
FORM= returns [aq]UNKNOWN[aq]
*
PAD= defaults to [aq]NO[aq] for formatted input.
*
NAMELIST and list-directed input of character strings must be delimited by apostrophes or quotes.
*
When processing NAMELIST input:
*
Column 1 of each record is skipped.
*
The [aq]$[aq] or [aq]&[aq] that appears prior to the group-name must appear in column 2 of the input record.
Alternate Options:

None

-Fa[filename|dir]
Specifies that an assembly listing file should be generated.
Arguments:
filename
Is the name of the assembly listing file.
dir
Is the directory where the file should be placed. It can include filename.
Default:
OFF
No assembly listing file is produced.
Description:

This option specifies that an assembly listing file should be generated (optionally named filename).

If filename is not specified, the file name will be the name of the source file with an extension of .asm; the file is placed in the current directory.

Alternate Options:

Linux and OS X: -S

Windows: /S, /asmfile (this is a deprecated option)

-falias
-fno-alias
Determines whether aliasing should be assumed in the program.
Arguments:

None

Default:
-fno-alias
No aliasing is assumed in the program.
Description:

This option determines whether aliasing should be assumed in the program.

If you want aliasing to be assumed in the program, specify -falias. However, this may affect performance.

Alternate Options:

Linux and OS X: None

-falign-functions[=n]
-fno-align-functions
Tells the compiler to align functions on an optimal byte boundary.
Arguments:
n
Is the byte boundary for function alignment. Possible values are 2 or 16.
Default:
-fno-align-functions
The compiler aligns functions on 2-byte boundaries. This is the same as specifying -falign-functions=2 (Linux* OS and OS X*).
Description:

This option tells the compiler to align functions on an optimal byte boundary. If you do not specify n, the compiler aligns the start of functions on 16-byte boundaries.

Alternate Options:

None

-falign-stack=mode (L*X only)
Tells the compiler the stack alignment to use on entry to routines.
Architecture Restrictions: Only available on IA-32 architecture
Arguments:
mode
Is the method to use for stack alignment. Possible values are:
assume-4-byte
Tells the compiler to assume the stack is aligned on 4-byte boundaries. The compiler can dynamically adjust the stack to 16-byte alignment if needed.
maintain-16-byte
Tells the compiler to not assume any specific stack alignment, but attempt to maintain alignment in case the stack is already aligned. The compiler can dynamically align the stack if needed. This setting is compatible with gcc.
assume-16-byte
Tells the compiler to assume the stack is aligned on 16-byte boundaries and to continue to maintain 16-byte alignment. This setting is compatible with gcc.
Default:
-falign-stack=assume-16-byte
The compiler assumes the stack is aligned on 16-byte boundaries and continues to maintain 16-byte alignment.
Description:

This option tells the compiler the stack alignment to use on entry to routines.

Alternate Options:

None

-fast
Maximizes speed across the entire program.
Arguments:

None

Default:
OFF
The optimizations that maximize speed are not enabled.
Description:

This option maximizes speed across the entire program.

It sets the following options:

On OS X* systems: -ipo, -mdynamic-no-pic, -O3, -no-prec-div, -fp-model fast=2, and -xHost On Windows* systems: /O3, /Qipo, /Qprec-div-, /fp:fast=2, and /QxHost On Linux* systems: -ipo, -O3, -no-prec-div, -static, -fp-model fast=2, and -xHost On Intel(R) 64 architecture-based systems that target Intel(R) MIC Architecture: [Q]ipo, O3, -no-prec-div (Linux* OS) or /Qprec-div- (Windows* OS), -fp-model fast=2 (Linux* OS) or /fp:fast=2 (Windows* OS)

When option fast is specified, you can override the [Q]xHost option setting by specifying a different processor-specific [Q]x option on the command line. However, the last option specified on the command line takes precedence.

For example:

*
On Linux* OS, if you specify option -fast -xSSE3, option -xSSE3 takes effect. However, if you specify -xSSE3 -fast, option -xHost takes effect.
*
On Windows* OS, if you specify option /fast /QxSSE3, option/QxSSE3 takes effect. However, if you specify /QxSSE3 /fast, option /QxHost takes effect.

For implications on non-Intel processors, refer to the [Q]xHost documentation.

NOTE: Option fast sets some aggressive optimizations that may not be appropriate for all applications. The resulting executable may not run on processor types different from the one on which you compile. You should make sure that you understand the individual optimization options that are enabled by option fast.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fast-transcendentals
-no-fast-transcendentals
Enables the compiler to replace calls to transcendental functions with faster but less precise implementations.
Arguments:

None

Default:
depends on the setting of -fp-model (Linux* OS and OS X*)
If you do not specify option -[no-]fast-transcendentals:
*
The default is ON if option -fp-model fast is specified or is in effect.
*
The default is OFF if a value-safe setting is specified for -fp-model (such as "precise", "source", etc.).
Description:

This option enables the compiler to replace calls to transcendental functions with implementations that may be faster but less precise.

It allows the compiler to perform certain optimizations on transcendental functions, such as replacing individual calls to sine in a loop with a single call to a less precise vectorized sine library routine.

This option does not affect explicit Short Vector Math Library (SVML) intrinsics. It only affects scalar calls to the standard math library routines.

You cannot use option –fast-transcendentals with option –fp-model strict.

This option determines the setting for the maximum allowable relative error for math library function results (max-error) if none of the following options are specified:

*
-fimf-accuracy-bits (Linux* OS and OS X*) or /Qimf-accuracy-bits (Windows* OS)
*
-fimf-max-error (Linux OS and OS X) or /Qimf-max-error (Windows OS)
*
-fimf-precision (Linux OS and OS X) or /Qimf-precision (Windows OS)

This option enables extra optimization that only applies to Intel(R) processors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fasynchronous-unwind-tables
-fno-asynchronous-unwind-tables
Determines whether unwind information is precise at an instruction boundary or at a call boundary.
Arguments:

None

Default:
Intel(R) 64 architecture: -fasynchronous-unwind-tables
The unwind table generated is precise at an instruction boundary, enabling accurate unwinding at any instruction.
IA-32 architecture: -fno-asynchronous-unwind-tables
The unwind table generated is precise at call boundaries only.
Description:

This option determines whether unwind information is precise at an instruction boundary or at a call boundary. The compiler generates an unwind table in DWARF2 or DWARF3 format, depending on which format is supported on your system.

If -fno-asynchronous-unwind-tables is specified, the unwind table is precise at call boundaries only. In this case, the compiler will avoid creating unwind tables for routines such as the following:

*
A C++ routine that does not declare objects with destructors and does not contain calls to routines that might throw an exception.
*
A C/C++ or Fortran routine compiled without -fexceptions, and on Intel(R) 64 architecture, without -traceback.
*
A C/C++ or Fortran routine compiled with -fexceptions that does not contain calls to routines that might throw an exception.
Alternate Options:

None

-fcode-asm
Produces an assembly listing with machine code annotations.
Arguments:

None

Default:
OFF
No machine code annotations appear in the assembly listing file, if one is produced.
Description:

This option produces an assembly listing file with machine code annotations.

The assembly listing file shows the hex machine instructions at the beginning of each line of assembly code. The file cannot be assembled; the file name is the name of the source file with an extension of .cod.

To use this option, you must also specify option -S, which causes an assembly listing to be generated.

Alternate Options:

Linux and OS X: None

-fcommon
-fno-common
Determines whether the compiler treats common symbols as global definitions.
Arguments:

None

Default:
-fcommon
The compiler does not treat common symbols as global definitions.
Description:

This option determines whether the compiler treats common symbols as global definitions and to allocate memory for each symbol at compile time.

Option -fno-common tells the compiler to treat common symbols as global definitions. When using this option, you can only have a common variable declared in one module; otherwise, a link time error will occur for multiple defined symbols.

Alternate Options:

None

-feliminate-unused-debug-types
-fno-eliminate-unused-debug-types
Controls the debug information emitted for types declared in a compilation unit.
Arguments:

None

Default:
-feliminate-unused-debug-types
The compiler emits debug information only for types that are actually used by a variable/parameter/etc..
Description:

This option controls the debug information emitted for types declared in a compilation unit.

If you specify -fno-eliminate-unused-debug-types (Linux and OS X) or /Qeliminate-unused-debug-types-, it will cause the compiler to emit debug information for all types present in the sources. This option may cause a large increase in the size of the debug information.

Alternate Options:

None

-fexceptions
-fno-exceptions
Enables exception handling table generation.
Arguments:

None

Default:
-fno-exceptions
Exception handling table generation is disabled.
Description:

This option enables C++ exception handling table generation, preventing Fortran routines in mixed-language applications from interfering with exception handling between C++ routines. The -fno-exceptions option 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.

Alternate Options:

None

-ffat-lto-objects (L*X only)
-fno-fat-lto-objects (L*X only)
Determines whether a fat link-time optimization (LTO) object, containing both intermediate language and object code, is generated during an interprocedural optimization compilation (-c –ipo).
Arguments:

None

Default:
-ffat-lto-objects
When –c –ipo is specified, the compiler generates a fat link-time optimization (LTO) object that has both a true object and a discardable intermediate language section.
Description:

This option determines whether a fat link time optimization (LTO) object, containing both intermediate language and object code, is generated during an interprocedural optimization compilation (-c –ipo).

During an interprocedural optimization compilation (-c –ipo), the following occurs:

*
If you specify -ffat-lto-objects, the compiler generates a fat link-time optimization (LTO) object that has both a true object and a discardable intermediate language section. This enables both link-time optimization (LTO) linking and normal linking.
*
If you specify -fno-fat-lto-objects, the compiler generates a fat link-time optimization (LTO) object that only has a discardable intermediate language section; no true object is generated. This option may improve compilation time.

Note that these files will be inserted into archives in the form in which they were created.

This option is provided for compatibility with gcc. For more information about this option, see the gcc documentation.

NOTE: Intel[aq]s intermediate language representation is not compatible with gcc’s intermediate language representation.

Alternate Options:

None

-ffnalias
-fno-fnalias
Specifies that aliasing should be assumed within functions.
Arguments:

None

Default:
-ffnalias
Aliasing is assumed within functions.
Description:

This option specifies that aliasing should be assumed within functions.

The -fno-fnalias option specifies that aliasing should not be assumed within functions, but should be assumed across calls.

Alternate Options:

Linux and OS X: None

-fimf-absolute-error=value[:funclist]
Defines the maximum allowable absolute error for math library function results.
Arguments:
value
Is a positive, floating-point number. Errors in math library function results may exceed the maximum relative error (max-error) setting if the absolute-error is less than or equal to value.
The format for the number is [digits] [.digits] [ { e | E }[sign]digits]
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-absolute-error=0.00001:sin,sinf (or /Qimf-absolute-error:0.00001:sin,sinf) to specify the maximum allowable absolute error for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-absolute-error=0.00001:/ or /Qimf-absolute-error: 0.00001:/.
Default:
Zero ("0")
An absolute-error setting of 0 means that the function is bound by the relative error setting. This is the default behavior.
Description:

This option defines the maximum allowable absolute error for math library function results.

This option can improve run-time performance, but it may decrease the accuracy of results.

This option only affects functions that have zero as a possible return value, such as log, sin, asin, etc.

The relative error requirements for a particular function are determined by options that set the maximum relative error (max-error) and precision. The return value from a function must have a relative error less than the max-error value, or an absolute error less than the absolute-error value.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-absolute-error=0.00001:sin or /Qimf-absolute-error:0.00001:sin, or -fimf-absolute-error=0.00001:sqrtf or /Qimf-absolute-error:0.00001:sqrtf.

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fimf-accuracy-bits=bits[:funclist]
Defines the relative error for math library function results, including division and square root.
Arguments:
bits
Is a positive, floating-point number indicating the number of correct bits the compiler should use.
The format for the number is [digits] [.digits] [ { e | E }[sign]digits].
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-accuracy-bits=23:sin,sinf (or /Qimf-accuracy-bits:23:sin,sinf) to specify the relative error for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-accuracy-bits=10.0:/f or /Qimf-accuracy-bits:10.0:/f.
Default:
-fimf-precision=medium or /Qimf-precision:medium
The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.
Description:

This option defines the relative error, measured by the number of correct bits, for math library function results.

The following formula is used to convert bits into ulps: ulps = 2p-1-bits, where p is the number of the target format mantissa bits (24, 53, and 113 for single, double, and quad precision, respectively).

This option can affect run-time performance and the accuracy of results.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in the following:

*
-fimf-accuracy-bits=23:sinf,cosf,logf or /Qimf-accuracy-bits:23:sinf,cosf,logf
*
-fimf-accuracy-bits=52:sqrt,/,trunc or /Qimf-accuracy-bits:52:sqrt,/,trunc
*
-fimf-accuracy-bits=10:powf or /Qimf-accuracy-bits:10:powf

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

There are three options you can use to express the maximum relative error. They are as follows:

*
-fimf-precision (Linux* OS and OS X*) or /Qimf-precision (Windows* OS)
*
-fimf-max-error (Linux* OS and OS X*) or /Qimf-max-error (Windows* OS)
*
-fimf-accuracy-bits (Linux OS and OS X*) or /Qimf-accuracy-bits (Windows OS)

If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

*
[Q]fast-transcendentals
*
[Q]prec-div
*
[Q]prec-sqrt
*
-fp-model (Linux OS and OS X) or /fp (Windows OS)

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fimf-arch-consistency=value[:funclist]
Ensures that the math library functions produce consistent results across different microarchitectural implementations of the same architecture.
Arguments:
value
Is one of the logical values "true" or "false".
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-arch-consistency=true:sin,sinf (or /Qimf-arch-consistency:true:sin,sinf) to specify consistent results for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-arch-consistency=true:/ or /Qimf-arch-consistency:true:/.
Default:
false
Implementations of some math library functions may produce slightly different results on implementations of the same architecture.
Description:

This option ensures that the math library functions produce consistent results across different microarchitectural implementations of the same architecture (for example, across different microarchitectural implementations of IA-32 architecture). Consistency is only guaranteed for a single binary. Consistency is not guaranteed across different architectures. For example, consistency is not guaranteed across IA-32 architecture and Intel(R) 64 architecture.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-arch-consistency=true:sin or /Qimf-arch-consistency:true:sin, or -fimf-arch-consistency=false:sqrtf or /Qimf-arch-consistency:false:sqrtf.

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

The -fimf-arch-consistency (Linux* OS and OS X*) and /Qimf-arch-consistency (Windows* OS) option may decrease run-time performance, but the option will provide bit-wise consistent results on all Intel(R) processors and compatible, non-Intel processors, regardless of micro-architecture. This option may not provide bit-wise consistent results between different architectures, for example, between IA-32 and Intel(R) 64 architectures, or between Intel(R) 64 architecture and Intel(R) MIC Architecture.

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fimf-domain-exclusion=classlist[:funclist]
Indicates the input arguments domain on which math functions must provide correct results.
Arguments:
classlist
Is one of the following:
*
One or more of the following floating-point value classes you can exclude from the function domain without affecting the correctness of your program. The supported class names are:
extremes This class is for values which do not lie within the usual domain of arguments for a given function. nans This means "x=Nan". infinities This means "x=infinities". denormals This means "x=denormal". zeros This means "x=0".
Each classlist element corresponds to a power of two. The exclusion attribute is the logical or of the associated powers of two (that is, a bitmask). The following shows the current mapping from classlist mnemonics to numerical values:
extremes
1
nans
2
infinities
4
denormals
8
zeros
16
none
0
all
31
common
15
other combinations
bitwise OR of the used values You must specify the integer value that corresponds to the class that you want to exclude. Note that on excluded values, unexpected results may occur.
*
One of the following short-hand tokens:
none This means that none of the supported classes are excluded from the domain. To indicate this token, specify 0, as in -fimf-domain-exclusion=0 (or /Qimf-domain-exclusion:0). all This means that all of the supported classes are excluded from the domain. To indicate this token, specify 31, as in -fimf-domain-exclusion=31 (or /Qimf-domain-exclusion:31). common This is the same as specifying extremes,nans,infinities,denormals. To indicate this token, specify 15 (1 + 2+ 4 + 8), as in -fimf-domain-exclusion=15 (or /Qimf-domain-exclusion:15)
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-domain-exclusion=4:sin,sinf (or /Qimf-domain-exclusion:4:sin,sinf) to specify infinities for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example, you can specify:
-fimf-domain-exclusion=4 or /Qimf-domain-exclusion:4
-fimf-domain-exclusion=5:/,powf or /Qimf-domain-exclusion:5:/,powf
-fimf-domain-exclusion=23:log,logf,/,sin,cosf or /Qimf-domain-exclusion:23:log,logf,/,sin,cosf
If you don’t specify argument funclist, the domain restrictions apply to all math library functions.
Default:
Zero ("0")
The compiler uses default heuristics when calling math library functions.
Description:

This option indicates the input arguments domain on which math functions must provide correct results. It specifies that your program will function correctly if the functions specified in funclist do not produce standard conforming results on the number classes.

This option can affect run-time performance and the accuracy of results. As more classes are excluded, faster code sequences can be used.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-domain-exclusion=denormals:sin or /Qimf-domain-exclusion:denormals:sin, or -fimf-domain-exclusion=extremes:sqrtf or /Qimf domain-exclusion:extremes:sqrtf.

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fimf-max-error=ulps[:funclist]
Defines the maximum allowable relative error for math library function results, including division and square root.
Arguments:
ulps
Is a positive, floating-point number indicating the maximum allowable relative error the compiler should use.
The format for the number is [digits] [.digits] [ { e | E }[sign]digits].
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-max-error=4.0:sin,sinf (or /Qimf-max-error=4.0:sin,sinf) to specify the maximum allowable relative error for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-max-error=4.0:/ or /Qimf-max-error:4.0:/.
Default:
-fimf-precision=medium or /Qimf-precision:medium
The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.
Description:

This option defines the maximum allowable relative error, measured in ulps, for math library function results.

This option can affect run-time performance and the accuracy of results.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-max-error=4.0:sin or /Qimf-max-error:4.0:sin, or -fimf-max-error=4.0:sqrtf or /Qimf-max-error:4.0:sqrtf.

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

There are three options you can use to express the maximum relative error. They are as follows:

*
-fimf-precision (Linux* OS and OS X*) or /Qimf-precision (Windows* OS)
*
-fimf-max-error (Linux* OS and OS X*) or /Qimf-max-error (Windows* OS)
*
-fimf-accuracy-bits (Linux OS and OS X*) or /Qimf-accuracy-bits (Windows OS)

If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

*
[Q]fast-transcendentals
*
[Q]prec-div
*
[Q]prec-sqrt
*
-fp-model (Linux OS and OS X) or /fp (Windows OS)

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fimf-precision[=value[:funclist]]
Lets you specify a level of accuracy (precision) that the compiler should use when determining which math library functions to use.
Arguments:
value
Is one of the following values denoting the desired accuracy:
high
This is equivalent to max-error = 0.6.
medium
This is equivalent to max-error = 4; this is the default setting if the option is specified and value is omitted.
low
This is equivalent to accuracy-bits = 11 for single-precision functions; accuracy-bits = 26 for double-precision functions.
In the above explanations, max-error means option -fimf-max-error (Linux* OS and OS X*) or /Qimf-max-error (Windows* OS); accuracy-bits means option -fimf-accuracy-bits (Linux* OS and OS X*) or /Qimf-accuracy-bits (Windows* OS).
funclist
Is an optional list of one or more math library functions to which the attribute should be applied. If you specify more than one function, they must be separated with commas. Precision-specific variants like sin and sinf are considered different functions, so you would need to use -fimf-precision=high:sin,sinf (or /Qimf-precision:high:sin,sinf) to specify high precision for both the single-precision and double-precision sine functions.
You also can specify the symbol /f to denote single-precision divides, symbol / to denote double-precision divides, symbol /l to denote extended-precision divides, and symbol /q to denote quad-precision divides. For example you can specify -fimf-precision=low:/ or /Qimf-precision:low:/ and -fimf-precision=low:/f or /Qimf-precision:low:/f.
Default:
medium
The compiler uses medium precision when calling math library functions. Note that other options can affect precision; see below for details.
Description:

This option lets you specify a level of accuracy (precision) that the compiler should use when determining which math library functions to use.

This option can be used to improve run-time performance if reduced accuracy is sufficient for the application, or it can be used to increase the accuracy of math library functions selected by the compiler.

In general, using a lower precision can improve run-time performance and using a higher precision may reduce run-time performance.

If you need to define the accuracy for a math function of a certain precision, specify the function name of the precision that you need. For example, if you want double precision, you can specify :sin; if you want single precision, you can specify :sinf, as in -fimf-precision=low:sin or /Qimf-precision:low:sin, or -fimf-precision=high:sqrtf or /Qimf-precision:high:sqrtf.

If you do not specify any function names, then the setting applies to all functions (and to all precisions). However, as soon as you specify an individual function name, the setting applies only to the function of corresponding precision. So, for example, sinf applies only to the single-precision sine function, sin applies only to the double-precision sine function, sinl applies only to the extended-precision sine function, etc.

There are three options you can use to express the maximum relative error. They are as follows:

*
-fimf-precision (Linux* OS and OS X*) or /Qimf-precision (Windows* OS)
*
-fimf-max-error (Linux* OS and OS X*) or /Qimf-max-error (Windows* OS)
*
-fimf-accuracy-bits (Linux OS and OS X*) or /Qimf-accuracy-bits (Windows OS)

If more than one of these options are specified, the default value for the maximum relative error is determined by the last one specified on the command line.

If none of the above options are specified, the default values for the maximum relative error are determined by the setting of the following options:

*
[Q]fast-transcendentals
*
[Q]prec-div
*
[Q]prec-sqrt
*
-fp-model (Linux OS and OS X) or /fp (Windows OS)

NOTE: Many routines in libraries LIBM (Math Library) and SVML (Short Vector Math Library) are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-finline
-fno-inline
Tells the compiler to inline functions declared with !DIR$ ATTRIBUTES FORCEINLINE.
Arguments:

None

Default:
-fno-inline
The compiler does not inline functions declared with !DIR$ ATTRIBUTES FORCEINLINE.
Description:

This option tells the compiler to inline functions declared with !DIR$ ATTRIBUTES FORCEINLINE.

Alternate Options:

Linux and OS X: -inline-level

-finline-functions
-fno-inline-functions
Enables function inlining for single file compilation.
Arguments:

None

Default:
-finline-functions
Interprocedural optimizations occur. However, if you specify -O0, the default is OFF.
Description:

This option enables function inlining for single file compilation.

It enables the compiler to perform inline function expansion for calls to functions defined within the current source file.

The compiler applies a heuristic to perform the function expansion. To specify the size of the function to be expanded, use the -finline-limit option.

Alternate Options:

Linux and OS X: -inline-level=2

-finline-limit=n
Lets you specify the maximum size of a function to be inlined.
Arguments:
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.
Default:
OFF
The compiler uses default heuristics when inlining functions.
Description:

This option lets you specify the maximum size of a function to be inlined. 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.

Note that parts of functions cannot be inlined, only whole functions.

This option is a modification of the -finline-functions option, whose behavior occurs by default.

Alternate Options:

None

-finstrument-functions
-fno-instrument-functions
Determines whether routine entry and exit points are instrumented.
Arguments:

None

Default:
-fno-instrument-functions
Routine entry and exit points are not instrumented.
Description:

This option determines whether routine entry and exit points are instrumented. It may increase execution time.

The following profiling functions are called with the address of the current routine and the address of where the routine was called (its "call site"):

*
This function is called upon routine entry:
*
void __cyg_profile_func_enter (void *this_fn,
void *call_site);
*
This function is called upon routine exit:
*
void __cyg_profile_func_exit (void *this_fn,
void *call_site);

These functions can be used to gather more information, such as profiling information or timing information. Note that it is the user[aq]s responsibility to provide these profiling functions.

If you specify -finstrument-functions (Linux* OS and OS X*) or /Qinstrument-functions (Windows* OS), routine inlining is disabled. If you specify -fno-instrument-functions or /Qinstrument-functions-, inlining is not disabled.

This option is provided for compatibility with gcc.

Alternate Options:

None

-fixed
-nofixed
Specifies source files are in fixed format.
Arguments:

None

Default:
OFF
The source file format is determined from the file extension.
Description:

This option specifies source files are in fixed format. If this option is not specified, format is determined as follows:

*
Files with an extension of .f90, .F90, or .i90 are free-format source files.
*
Files with an extension of .f, .for, .FOR, .ftn, .FTN, .fpp, .FPP, or .i are fixed-format files.

Note that on Linux* and OS X* systems, file names and file extensions are case sensitive.

Alternate Options:

Linux and OS X: -FI

-fkeep-static-consts
-fno-keep-static-consts
Tells the compiler to preserve allocation of variables that are not referenced in the source.
Arguments:

None

Default:
-fno-keep-static-consts
If a variable is never referenced in a routine, the variable is discarded unless optimizations are disabled by option -O0 (Linux* OS and OS X*).
Description:

This option tells the compiler to preserve allocation of variables that are not referenced in the source.

The negated form can be useful when optimizations are enabled to reduce the memory usage of static data.

Alternate Options:

None

-fltconsistency
-nofltconsistency
Enables improved floating-point
consistency.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
nofltconsistency
Improved floating-point consistency is not enabled. This setting provides better accuracy and run-time performance at the expense of less consistent floating-point results.
Description:

This option enables improved floating-point consistency and may slightly reduce execution speed. It limits floating-point optimizations and maintains declared precision. It also disables inlining of math library functions.

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.

For example, the compiler can change floating-point division computations into multiplication by the reciprocal of the denominator. This change can alter the results of floating-point division computations slightly.

Floating-point intermediate results are kept in full 80 bits internal precision. Additionally, all spills/reloads of the X87 floating point registers are done using the internal formats; this prevents accidental loss of precision due to spill/reload behavior over which you have no control.

Specifying this option has the following effects on program compilation:

*
Floating-point user variables are not assigned to registers.
*
Floating-point arithmetic comparisons conform to IEEE 754.
*
The exact operations specified in the code are performed. For example, division is never changed to multiplication by the reciprocal.
*
The compiler performs floating-point operations in the order specified without reassociation.
*
The compiler does not perform constant folding on floating-point values. Constant folding also eliminates any multiplication by 1, division by 1, and addition or subtraction of 0. For example, code that adds 0.0 to a number is executed exactly as written. Compile-time floating-point arithmetic is not performed to ensure that floating-point exceptions are also maintained.
*
Whenever an expression is spilled, it is spilled as 80 bits (extended precision), not 64 bits (DOUBLE PRECISION). When assignments to type REAL and DOUBLE PRECISION are made, the precision is rounded from 80 bits down to 32 bits (REAL) or 64 bits (DOUBLE PRECISION). When you do not specify /fltconsistency, the extra bits of precision are not always rounded away before the variable is reused.
*
Even if vectorization is enabled by the [Q]x option, the compiler does not vectorize reduction loops (loops computing the dot product) and loops with mixed precision types. Similarly, the compiler does not enable certain loop transformations. For example, the compiler does not transform reduction loops to perform partial summation or loop interchange.

This option causes performance degradation relative to using default floating-point optimization flags.

On Windows systems, an alternative is to use the /Qprec option, which should provide better than default floating-point precision while still delivering good floating-point performance.

The recommended method to control the semantics of floating-point calculations is to use option -fp-model (Linux* OS and OS X*) or /fp (Windows* OS).

Alternate Options:
fltconsistency
Linux and OS X: -mieee-fp
nofltconsistency
Linux and OS X: -mno-ieee-fp
-fma
-no-fma
Determines whether the compiler generates fused multiply-add (FMA) instructions if such instructions exist on the target processor.
Arguments:

None

Default:
-fma
If the instructions exist on the target processor, the compiler generates fused multiply-add (FMA) instructions.
However, if you specify -fp-model strict (Linux* OS and OS X*), but do not explicitly specify -fma, the default is -no-fma.
Description:

This option determines whether the compiler generates fused multiply-add (FMA) instructions if such instructions exist on the target processor. When the [Q]fma option is specified, the compiler may generate FMA instructions for combining multiply and add operations. When the negative form of the [Q]fma option is specified, the compiler must generate separate multiply and add instructions with intermediate rounding.

This option has no effect unless setting CORE-AVX2 or higher is specified for option [Q]x, -march (Linux OS and OS X), or /arch (Windows OS).

-fmath-errno
-fno-math-errno
Tells the compiler that errno can be reliably tested after calls to standard math library functions.
Arguments:

None

Default:
-fno-math-errno
The compiler assumes that the program does not test errno after calls to standard math library functions.
Description:

This option 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.

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

Alternate Options:

None

-fmerge-constants (L*X only)
-fno-merge-constants (L*X only)
Determines whether the compiler and linker attempt to merge identical constants (string constants and floating-point constants) across compilation units.
Arguments:

None

Default:
-fmerge-constants
The compiler and linker attempt to merge identical constants across compilation units if the compiler and linker supports it.
Description:

This option determines whether the compiler and linker attempt to merge identical constants (string constants and floating-point constants) across compilation units.

If you do not want the compiler and linker to attempt to merge identical constants across compilation units. specify -fno-merge-constants.

Alternate Options:

None

-fmerge-debug-strings (L*X only)
-fno-merge-debug-strings (L*X only)
Causes the compiler to pool strings used in debugging information.
Arguments:

None

Default:
-fmerge-debug-strings
The compiler will pool strings used in debugging information.
Description:

This option causes the compiler to pool strings used in debugging information. The linker will automatically retain this pooling.

This option can reduce the size of debug information, but it may produce slightly slower compile and link times.

This option is only turned on by default if you are using gcc 4.3 or later, where this setting is also the default, since the generated debug tables require binutils version 2.17 or later to work reliably.

If you do not want the compiler to pool strings used in debugging information, specify option -fno-merge-debug-strings.

Alternate Options:

None

-fminshared
Specifies that a compilation unit is a component of a main program and should not be linked as part of a shareable object.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
Source files are compiled together to form a single object file.
Description:

This option specifies that a compilation unit is a component of a main program and should not be linked as part of a shareable object.

This option allows the compiler to optimize references to defined symbols without special visibility settings. To ensure that external and common symbol references are optimized, you need to specify visibility hidden or protected by using the -fvisibility, -fvisibility-hidden, or -fvisibility-protected option.

Also, the compiler does not need to generate position-independent code for the main program. It can use absolute addressing, which may reduce the size of the global offset table (GOT) and may reduce memory traffic.

Alternate Options:

None

-fmpc-privatize (L*X only)
-fno-mpc-privatize (L*X only)
Enables or disables privatization of all static data for the MultiProcessor Computing environment (MPC) unified parallel runtime.
Architecture Restrictions: Only available on Intel(R) 64 architecture
Arguments:

None

Default:
-fno-mpc-privatize
The privatization of all static data for the MPC unified parallel runtime is disabled.
Description:

This option enables or disables privatization of all static data for the MultiProcessor Computing environment (MPC) unified parallel runtime.

Option -fmpc-privatize causes calls to extended thread-local-storage (TLS) resolution, run-time routines that are not supported on standard Linux* OS distributions.

This option requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-fomit-frame-pointer
-fno-omit-frame-pointer
Determines whether EBP is used as a general-purpose register in optimizations.
Architecture Restrictions: Option /Oy[-] is only available on IA-32 architecture
Arguments:

None

Default:
-fomit-frame-pointer
EBP is used as a general-purpose register in optimizations. However, on Linux* and OS X* systems, the default is -fno-omit-frame-pointer if option -O0 or -g is specified.
Description:

These options determine whether EBP is used as a general-purpose register in optimizations. Options -fomit-frame-pointer and /Oy allow this use. Options -fno-omit-frame-pointer and /Oy- disallow it.

Some debuggers expect EBP to be used as a stack frame pointer, and cannot produce a stack backtrace unless this is so. The -fno-omit-frame-pointer and /Oy- options direct the compiler to generate code that maintains and uses EBP as a stack frame pointer for all functions so that a debugger can still produce a stack backtrace without doing the following:

*
For -fno-omit-frame-pointer: turning off optimizations with -O0
*
For /Oy-: turning off /O1, /O2, or /O3 optimizations

The -fno-omit-frame-pointer option is set when you specify option -O0 or the -g option. The -fomit-frame-pointer option is set when you specify option -O1, -O2, or -O3.

The /Oy option is set when you specify the /O1, /O2, or /O3 option. Option /Oy- is set when you specify the /Od option.

Using the -fno-omit-frame-pointer or /Oy- option reduces the number of available general-purpose registers by 1, and can result in slightly less efficient code.

Alternate Options:

Linux and OS X: -fp (this is a deprecated option)

-foptimize-sibling-calls
-fno-optimize-sibling-calls
Determines whether the compiler optimizes tail recursive calls.
Arguments:

None

Default:
-foptimize-sibling-calls
The compiler optimizes tail recursive calls.
Description:

This option determines whether the compiler optimizes tail recursive calls. It enables conversion of tail recursion into loops.

If you do not want to optimize tail recursive calls, specify -fno-optimize-sibling-calls.

Tail recursion is a special form of recursion that doesn[aq]t use stack space. In tail recursion, a recursive call is converted to a GOTO statement that returns to the beginning of the function. In this case, the return value of the recursive call is only used to be returned. It is not used in another expression. The recursive function is converted into a loop, which prevents modification of the stack space used.

Alternate Options:

None

-fp-model keyword
Controls the semantics of floating-point calculations.
Arguments:
keyword
Specifies the semantics to be used. Possible values are:
precise
Disables optimizations that are not value-safe on floating-point data and rounds intermediate results to source-defined precision.
fast[=1|2]
Enables more aggressive optimizations on floating-point data.
strict
Enables precise and except, disables contractions, and enables the property that allows modification of the floating-point environment.
source
Rounds intermediate results to source-defined precision.
[no-]except (Linux* OS and OS X*) or except[-] (Windows* OS)
Determines whether strict floating-point exception semantics are honored.
Default:
-fp-model fast=1
The compiler uses more aggressive optimizations on floating-point calculations.
Description:

This option controls the semantics of floating-point calculations.

The keywords can be considered in groups:

*
Group A: precise, fast, strict
*
Group B: source
*
Group C: except (or the negative form)

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, group B, and group C. Since fast is the default, you must not specify except without a group A or group B keyword.
*
You should specify only one keyword from group A and only one keyword from group B. If you try to specify more than one keyword from either group A or group B, the last (rightmost) one takes effect.
*
If you specify except more than once, the last (rightmost) one takes effect.

The floating-point (FP) environment is a collection of registers that control the behavior of FP machine instructions and indicate the current FP status. The floating-point environment may include rounding-mode controls, exception masks, flush-to-zero controls, exception status flags, and other floating-point related features.

Option
Description
-fp-model precise or /fp:precise
Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations. It disables optimizations that can change the result of floating-point calculations.
These semantics ensure the reproducibility of floating-point computations for serial code, including code vectorized or auto-parallelized by the compiler, but they may slow performance. They do not ensure value safety or run-to-run reproducibility of other parallel code.
Run-to-run reproducibility for floating-point reductions in OpenMP* code may be obtained for a fixed number of threads through the KMP_DETERMINISTIC_REDUCTION environment variable. For more information about this environment variable, see topic "Supported Environment Variables".
The compiler assumes the default floating-point environment; you are not allowed to modify it.
Note that option fp-model precise is converted to fp-model source and option fp:precise is converted to fp:source.
IA-32 architecture: Windows: Double; Linux: Extended; OS X: Extended
Intel(R) 64 architecture: All operating systems: Source
Floating-point exception semantics are disabled by default. To enable these semantics, you must also specify -fp-model except or /fp:except.
Note that option fp-model precise enables option assume protect-parens, which tells the optimizer to honor parentheses in REAL and COMPLEX expression evaluations by not reassociating operations.
-fp-model fast[=1|2] or /fp:fast[=1|2]
Tells the compiler to use more aggressive optimizations when implementing floating-point calculations. These optimizations increase speed, but may affect the accuracy or reproducibility 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 because you cannot specify fast and except together in the same compilation. To enable exception semantics, you must explicitly specify another keyword (see other keyword descriptions for details).
-fp-model strict or /fp:strict
Tells the compiler to strictly adhere to value-safe optimizations when implementing floating-point calculations and enables floating-point exception semantics. This is the strictest floating-point model.
The compiler does not assume the default floating-point environment; you are allowed to modify it.
Floating-point exception semantics can be disabled by explicitly specifying -fp-model no-except or /fp:except-.
-fp-model source or /fp:source
This option causes intermediate results to be rounded to the precision defined in the source code. It also implies keyword precise unless it is overridden by a keyword from Group A.
long double: 64-bit precision; 80-bit data type; 15-bit exponent
double: 53-bit precision; 64-bit data type; 11-bit exponent; on Windows systems using IA-32 architecture, the exponent may be 15-bit if an x87 register is used to hold the value.
float: 24-bit precision; 32-bit data type; 8-bit exponent
The compiler assumes the default floating-point environment; you are not allowed to modify it.
Note that option fp-model source enables option assume protect-parens, which tells the optimizer to honor parentheses in REAL and COMPLEX expression evaluations by not reassociating operations.
-fp-model except or /fp:except
Tells the compiler to follow strict floating-point exception semantics.

The -fp-model and /fp options determine the setting for the maximum allowable relative error for math library function results (max-error) if none of the following options are specified:

*
-fimf-accuracy-bits (Linux* OS and OS X*) or /Qimf-accuracy-bits (Windows* OS)
*
-fimf-max-error (Linux OS and OS X) or /Qimf-max-error (Windows OS)
*
-fimf-precision (Linux OS and OS X) or /Qimf-precision (Windows OS)
*
[Q]fast-transcendentals

Option -fp-model fast (and /fp:fast) sets option -fimf-precision=medium (/Qimf-precision:medium) and option -fp-model precise (and /fp:precise) implies -fimf-precision=high (and /Qimf-precision:high). Option -fp-model fast=2 (and /fp:fast2) sets option -fimf-precision=medium (and /Qimf-precision:medium) and option -fimf-domain-exclusion=15 (and /Qimf-domain-exclusion=15).

NOTE: This option cannot be used to change the default (source) precision for the calculation of intermediate results.

NOTE: On Windows and Linux operating systems on IA-32 architecture, the compiler, by default, implements floating-point (FP) arithmetic using SSE2 and SSE instructions. This can cause differences in floating-point results when compared to previous x87 implementations.

NOTE:

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-fp-port
-no-fp-port
Rounds floating-point results after floating-point operations.
Arguments:

None

Default:
-no-fp-port
The default rounding behavior depends on the compiler[aq]s code generation decisions and the precision parameters of the operating system.
Description:

This option rounds floating-point results after floating-point operations.

This option is designed to be used with the -mia32 (Linux* OS and OS X*) or /arch:IA32 (Windows* OS ) option on a 32-bit compiler. Under those conditions, the compiler implements floating-point calculations using the x87 instruction set, which uses an internal precision that may be higher than the precision specified in the program.

By default, the compiler may keep results of floating-point operations in this higher internal precision. Rounding to program precision occurs at unspecified points. This provides better performance, but the floating-point results are less deterministic. The [Q]fp-port option rounds floating-point results to user-specified precision at assignments and type conversions. This has some impact on speed.

When compiling for newer architectures, the compiler implements floating-point calculations with different instructions, such as Intel(R) SSE and SSE2. These Intel(R) Streaming SIMD Extensions round directly to single precision or double precision at every instruction. In these cases, option [Q]fp-port has no effect.

Alternate Options:

None

-fp-speculation=mode
Tells the compiler the mode in which to speculate on floating-point operations.
Arguments:
mode
Is the mode for floating-point operations. Possible values are:
fast
Tells the compiler to speculate on floating-point operations.
safe
Tells the compiler to disable speculation if there is a possibility that the speculation may cause a floating-point exception.
strict
Tells the compiler to disable speculation on floating-point operations.
off
This is the same as specifying strict.
Default:
-fp-speculation=fast
The compiler speculates on floating-point operations. This is also the behavior when optimizations are enabled. However, if you specify no optimizations (-O0 on Linux* OS), the default is -fp-speculation=safe (Linux* OS).
Description:

This option tells the compiler the mode in which to speculate on floating-point operations.

Disabling speculation may prevent the vectorization of some loops containing conditionals. For an example, see this article.

Alternate Options:

None

-fp-stack-check
Tells the compiler to generate extra code after every function call to ensure that the floating-point stack is in the expected state.
Arguments:

None

Default:
OFF
There is no checking to ensure that the floating-point (FP) stack is in the expected state.
Description:

This option tells the compiler to generate extra code after every function call to ensure that the floating-point (FP) 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 program[aq]s results differ. Unfortunately, the overflow point can be far away from the point of the actual bug. This option places code that causes an access violation exception immediately after an incorrect call occurs, thus making it easier to locate these issues.

Alternate Options:

None

-fpconstant
-nofpconstant
Tells the compiler that single-precision constants assigned to double-precision variables should be evaluated in double precision.
Arguments:

None

Default:
nofpconstant
Single-precision constants assigned to double-precision variables are evaluated in single precision according to Fortran 2003 Standard rules.
Description:

This option tells the compiler that single-precision constants assigned to double-precision variables should be evaluated in double precision.

This is extended precision. It does not comply with the Fortran 2003 standard, which requires that single-precision constants assigned to double-precision variables be evaluated in single precision.

It allows compatibility with FORTRAN 77, where such extended precision was allowed. If this option is not used, certain programs originally created for FORTRAN 77 compilers may show different floating-point results because they rely on the extended precision for single-precision constants assigned to double-precision variables.

Alternate Options:

None

-fpen
Allows some control over floating-point
exception handling for the main program at run-time.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
n
Specifies the floating-point exception handling level. Possible values are:
0
Floating-point invalid, divide-by-zero, and overflow exceptions are enabled throughout the application when the main program is compiled with this value. If any such exceptions occur, execution is aborted. This option causes denormalized floating-point results to be set to zero. Underflow results will also be set to zero, unless you override this by explicitly specifying option -no-ftz or -fp-model precise (Linux* OS and OS X*) or option /Qftz- or /fp:precise (Windows* OS).
Underflow results from SSE instructions, as well as x87 instructions, will be set to zero. By contrast, option [Q]ftz only sets SSE underflow results to zero.
Sets option -fp-speculation=strict (Linux* and OS X*) or /Qfp-speculation:strict (Windows*) for any program unit compiled with -fpe0 (Linux* and OS X*) or /fpe:0 (Windows*). This disables certain optimizations in cases where speculative execution of floating-point operations could lead to floating-point exceptions that would not occur in the absence of speculation. For example, this may prevent the vectorization of some loops containing conditionals.
To get more detailed location information about where the error occurred, use option traceback.
1
All floating-point exceptions are disabled.
Underflow results from SSE instructions, as well as x87 instructions, will be set to zero.
3
All floating-point exceptions are disabled. Floating-point underflow is gradual, unless you explicitly specify a compiler option that enables flush-to-zero, such as [Q]ftz, O3, or O2. This setting provides full IEEE support.
Default:
-fpe3
All floating-point exceptions are disabled. Floating-point underflow is gradual, unless you explicitly specify a compiler option that enables flush-to-zero.
Description:

This option allows some control over floating-point exception handling at run-time. This includes whether exceptional floating-point values are allowed and how precisely run-time exceptions are reported.

The fpe option affects how the following conditions are handled:

*
When floating-point calculations result in a divide by zero, overflow, or invalid operation.
*
When floating-point calculations result in an underflow.
*
When a denormalized number or other exceptional number (positive infinity, negative infinity, or a NaN) is present in an arithmetic expression.

When enabled exceptions occur, execution is aborted and the cause of the abort reported to the user. If compiler option traceback is specified at compile time, detailed information about the location of the abort is also reported.

This option does not enable underflow exceptions, input denormal exceptions, or inexact exceptions.

Alternate Options:

None

-fpe-all=n
Allows some control over floating-point
exception handling for each routine in a program at run-time.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
n
Specifies the floating-point exception handling level. Possible values are:
0
Floating-point invalid, divide-by-zero, and overflow exceptions are enabled. If any such exceptions occur, execution is aborted. This option sets the [Q]ftz option; therefore underflow results will be set to zero unless you explicitly specify -no-ftz (Linux OS and OS X) or /Qftz- (Windows OS).
To get more detailed location information about where the error occurred, use option traceback.
1
All floating-point exceptions are disabled.
Underflow results from SSE instructions, as well as x87 instructions, will be set to zero.
3
All floating-point exceptions are disabled. Floating-point underflow is gradual, unless you explicitly specify a compiler option that enables flush-to-zero, such as [Q]ftz, O3, or O2. This setting provides full IEEE support.
Default:
-fpe-all=3
or the setting of fpe that the main program was compiled with All floating-point exceptions are disabled. Floating-point underflow is gradual, unless you explicitly specify a compiler option that enables flush-to-zero.
Description:

This option allows some control over floating-point exception handling for each routine in a program at run-time. This includes whether exceptional floating-point values are allowed and how precisely run-time exceptions are reported.

The fpe-all option affects how the following conditions are handled:

*
When floating-point calculations result in a divide by zero, overflow, or invalid operation.
*
When floating-point calculations result in an underflow.
*
When a denormalized number or other exceptional number (positive infinity, negative infinity, or a NaN) is present in an arithmetic expression.

The current settings of the floating-point exception and status flags are saved on each routine entry and restored on each routine exit. This may incur some performance overhead.

When option fpe-all is applied to a main program, it has the same effect as when option fpe is applied to the main program.

When enabled exceptions occur, execution is aborted and the cause of the abort reported to the user. If compiler option traceback is specified at compile time, detailed information about the location of the abort is also reported.

This option does not enable underflow exceptions, input denormal exceptions, or inexact exceptions.

Option fpe-all sets option assume ieee_fpe_flags.

Alternate Options:

None

-fpic
-fno-pic
Determines whether the compiler generates position-independent code.
Arguments:

None

Default:
-fno-pic
The compiler does not generate position-independent code.
Description:

This option determines whether the compiler generates position-independent code.

Option -fpic specifies full symbol preemption. Global symbol definitions as well as global symbol references get default (that is, preemptable) visibility unless explicitly specified otherwise.

Option -fpic must be used when building shared objects.

This option can also be specified as -fPIC.

Alternate Options:

None

-fpie (L*X only)
Tells the compiler to generate position-independent code. The generated code can only be linked into executables.
Arguments:

None

Default:
OFF
The compiler does not generate position-independent code for an executable-only object.
Description:

This option tells the compiler to generate position-independent code. It is similar to -fpic, but code generated by -fpie can only be linked into an executable.

Because the object is linked into an executable, this option causes better optimization of some symbol references.

To ensure that run-time libraries are set up properly for the executable, you should also specify option -pie to the compiler driver on the link command line.

Option -fpie can also be specified as -fPIE.

Alternate Options:

None

-fpp
-nofpp
Runs the Fortran preprocessor on source files before compilation.
Arguments:
fpp_option
Is a Fortran preprocessor (fpp) option; it must start with a slash (/) and appear in quotes. This argument is only allowed on Windows* systems.
Default:
nofpp
The Fortran preprocessor is not run on files before compilation.
Description:

This option runs the Fortran preprocessor on source files before they are compiled.

If you want to pass fpp options to the Fortran preprocessor, you can use any of the following methods:

*
Use option Qoption,fpp,"option". This is the recommended method.
*
On Windows* OS, use this option (fpp) and include the argument fpp_option (for example, fpp:"/macro=no").
*
On Linux* OS and OS X*, use option -Wp,fpp_option (for example, -Wp,-macro=no).

To see a list of all available fpp options, specify one of the following on the command line:

fpp -help     ! Linux and OS X systems

fpp /help     ! Windows systems

Alternate Options:

Linux and OS X: -cpp (this is a deprecated option)

-fpp-name=name
Lets you specify an alternate preprocessor to use with Fortran.
Arguments:
name
Is the name of the preprocessor executable. It can include a path. See the description below for more details.
Default:
OFF
No preprocessor is run on files before compilation.
Description:

This option lets you specify an alternate preprocessor to use with Fortran.

The compiler invokes the user-specified Fortran preprocessor by spawning a command with the following signature:

alt_fpp [ [–D<define>]..] [[-I<include directory>]..] inputfile

where alt_fpp is the name of the Fortran preprocessor you want to use. Output from the preprocessor goes to STDOUT and will be captured for any further processing.

You can use option Qoption,fpp,… to pass options, other than the definitions (-D xxx) or include directories (-I xxx), to the preprocessor.

You can use option Qlocation, fpp,… to specify a directory for supporting tools.

Alternate Options:

None

-fprotect-parens
-fno-protect-parens
Determines whether the optimizer honors parentheses when expressions are evaluated.
Arguments:

None

Default:
-fno-protect-parens
Parentheses are ignored when determining the order of expression evaluation.
Description:

This option determines whether the optimizer honors parentheses when determining the order of expression evaluation.

When option -fprotect-parens (Linux* OS and OS X*) or /Qprotect-parens (Windows* OS) is specified, the optimizer will maintain the order of evaluation imposed by parentheses in the code.

When the option -fno-protect-parens (Linux* OS and OS X*) or /Qprotect-parens- (Windows* OS) is specified, the optimizer may reorder expressions without regard for parentheses if it produces faster executing code.

Alternate Options:

None

-fpscomp [keyword[, keyword...]]
-nofpscomp
Controls whether certain aspects of the run-time system and semantic language features within the compiler are compatible with Intel(R) Fortran or Microsoft* Fortran PowerStation.
Arguments:
keyword
Specifies the compatibility that the compiler should follow. Possible values are:
none
Specifies that no options should be used for compatibility.
[no]filesfromcmd
Determines what compatibility is used when the OPEN statement FILE= specifier is blank.
[no]general
Determines what compatibility is used when semantics differences exist between Fortran PowerStation and Intel(R) Fortran.
[no]ioformat
Determines what compatibility is used for list-directed formatted and unformatted I/O.
[no]libs
Determines whether the portability library is passed to the linker.
[no]ldio_spacing
Determines whether a blank is inserted at run-time after a numeric value before a character value.
[no]logicals
Determines what compatibility is used for representation of LOGICAL values.
all
Specifies that all options should be used for compatibility.
Default:
fpscomp libs
The portability library is passed to the linker.
Description:

This option controls whether certain aspects of the run-time system and semantic language features within the compiler are compatible with Intel Fortran or Microsoft* Fortran PowerStation.

If you experience problems when porting applications from Fortran PowerStation, specify fpscomp (or fpscomp all). When porting applications from Intel Fortran, use fpscomp none or fpscomp libs (the default).

Option
Description
fpscomp none
Specifies that no options should be used for compatibility with Fortran PowerStation. This is the same as specifying nofpscomp. Option fpscomp none enables full Intel(R) Fortran compatibility. If you omit fpscomp, the default is fpscomp libs. You cannot use the fpscomp and vms options in the same command.
fpscomp filesfromcmd
Specifies Fortran PowerStation behavior when the OPEN statement FILE= specifier is blank (FILE=[aq] [aq]). It causes the following actions to be taken at run time:
*
The program reads a file name from the list of arguments (if any) in the command line that invoked the program. If any of the command-line arguments contain a null string ([aq][aq]), the program asks the user for the corresponding file name. Each additional OPEN statement with a blank FILE= specifier reads the next command-line argument.
*
If there are more nameless OPEN statements than command-line arguments, the program prompts for additional file names.
*
In a QuickWin application, a "File Select" dialog box appears to request file names.
To prevent the run-time system from using the file name specified on the command line when the OPEN statement FILE specifier is omitted, specify fpscomp nofilesfromcmd. This allows the application of Intel Fortran defaults, such as the FORTn environment variable and the FORT. n file name (where n is the unit number).
The fpscomp filesfromcmd option affects the following Fortran features:
*
The OPEN statement FILE specifier For example, assume a program OPENTEST contains the following statements: OPEN(UNIT = 2, FILE = [aq] [aq]) OPEN(UNIT = 3, FILE = [aq] [aq]) OPEN(UNIT = 4, FILE = [aq] [aq]) The following command line assigns the file TEST.DAT to unit 2, prompts the user for a file name to associate with unit 3, then prompts again for a file name to associate with unit 4: opentest test.dat [aq][aq] [aq][aq]
*
Implicit file open statements such as the WRITE, READ, and ENDFILE statements Unopened files referred to in READ or WRITE statements are opened implicitly as if there had been an OPEN statement with a name specified as all blanks. The name is read from the command line.
fpscomp general
Specifies that Fortran PowerStation semantics should be used when a difference exists between Intel Fortran and Fortran PowerStation. The fpscomp general option affects the following Fortran features:
*
The BACKSPACE statement:
*
It allows files opened with ACCESS=[aq]APPEND[aq] to be used with the BACKSPACE statement.
*
It allows files opened with ACCESS=[aq]DIRECT[aq] to be used with the BACKSPACE statement.
Note: Allowing files that are not opened with sequential access (such as ACCESS=[aq]DIRECT[aq]) to be used with the BACKSPACE statement violates the Fortran 95 standard and may be removed in the future.
*
The READ statement:
*
It causes a READ from a formatted file opened for direct access to read records that have the same record type format as Fortran PowerStation. This consists of accounting for the trailing Carriage Return/Line Feed pair (<CR><LF>) that is part of the record. It allows sequential reads from a formatted file opened for direct access. Note: Allowing files that are not opened with sequential access (such as ACCESS=[aq]DIRECT[aq]) to be used with the sequential READ statement violates the Fortran 95 standard and may be removed in the future.
*
It allows the last record in a file opened with FORM=[aq]FORMATTED[aq] and a record type of STREAM_LF or STREAM_CR that does not end with a proper record terminator (<line feed> or <carriage return>) to be read without producing an error.
*
It allows sequential reads from an unformatted file opened for direct access.
*
Note: Allowing files that are not opened with sequential access (such as ACCESS=[aq]DIRECT[aq]) to be read with the sequential READ statement violates the Fortran 95 standard and may be removed in the future.
*
The INQUIRE statement:
*
The CARRIAGECONTROL specifier returns the value "UNDEFINED" instead of "UNKNOWN" when the carriage control is not known.
*
The NAME specifier returns the file name "UNKNOWN" instead of filling the file name with spaces when the file name is not known.
*
The SEQUENTIAL specifier returns the value "YES" instead of "NO" for a direct access formatted file.
*
The UNFORMATTED specifier returns the value "NO" instead of "UNKNOWN" when it is not known whether unformatted I/O can be performed to the file. Note: Returning the value "NO" instead of "UNKNOWN" for this specifier violates the Fortran 95 standard and may be removed in the future.
*
The OPEN statement:
*
If a file is opened with an unspecified STATUS keyword value, and is not named (no FILE specifier), the file is opened as a scratch file. For example: OPEN (UNIT = 4)
*
In contrast, when fpscomp nogeneral is in effect with an unspecified STATUS value with no FILE specifier, the FORTn environment variable and the FORT.n file name are used (where n is the unit number).
*
If the STATUS value was not specified and if the name of the file is "USER", the file is marked for deletion when it is closed.
*
It allows a file to be opened with the APPEND and READONLY characteristics.
*
If the default for the CARRIAGECONTROL specifier is assumed, it gives "LIST" carriage control to direct access formatted files instead of "NONE".
*
If the default for the CARRIAGECONTROL specifier is assumed and the device type is a terminal file, the file is given the default carriage control value of "FORTRAN" instead of "LIST".
*
It gives an opened file the additional default of write sharing.
*
It gives the file a default block size of 1024 instead of 8192.
*
If the default for the MODE and ACTION specifier is assumed and there was an error opening the file, try opening the file as read only, then write only.
*
If a file that is being re-opened has a different file type than the current existing file, an error is returned.
*
It gives direct access formatted files the same record type as Fortran PowerStation. This means accounting for the trailing Carriage Return/Line Feed pair (<CR><LF>) that is part of the record.
*
The STOP statement: It writes the Fortran PowerStation output string and/or returns the same exit condition values.
*
The WRITE statement:
*
Writing to formatted direct files When writing to a formatted file opened for direct access, records are written in the same record type format as Fortran PowerStation. This consists of adding the trailing Carriage Return/Line Feed pair <CR><LF>) that is part of the record. It ignores the CARRIAGECONTROL specifier setting when writing to a formatted direct access file.
*
Interpreting Fortran carriage control characters When interpreting Fortran carriage control characters during formatted I/O, carriage control sequences are written that are the same as Fortran PowerStation. This is true for the "Space, 0, 1 and + " characters.
*
Performing non-advancing I/O to the terminal When performing non-advancing I/O to the terminal, output is written in the same format as Fortran PowerStation.
*
Interpreting the backslash () and dollar ($) edit descriptors When interpreting backslash and dollar edit descriptors during formatted I/O, sequences are written the same as Fortran PowerStation.
*
Performing sequential writes It allows sequential writes from an unformatted file opened for direct access. Note: Allowing files that are not opened with sequential access (such as ACCESS=[aq]DIRECT[aq]) to be read with the sequential WRITE statement violates the Fortran 95 standard and may be removed in the future.
Specifying fpscomp general sets fpscomp ldio_spacing.
fpscomp ioformat
Specifies that Fortran PowerStation semantic conventions and record formats should be used for list-directed formatted and unformatted I/O. The fpscomp ioformat option affects the following Fortran features:
*
The WRITE statement:
*
For formatted list-directed WRITE statements, formatted internal list-directed WRITE statements, and formatted namelist WRITE statements, the output line, field width values, and the list-directed data type semantics are determined according to the following sample for real constants (N below): For 1 <= N < 10**7, use F15.6 for single precision or F24.15 for double. For N < 1 or N >= 10**7, use E15.6E2 for single precision or E24.15E3 for double. See the Fortran PowerStation documentation for more detailed information about the other data types affected.
*
For unformatted WRITE statements, the unformatted file semantics are dictated according to the Fortran PowerStation documentation; these semantics are different from the Intel Fortran file format. See the Fortran PowerStation documentation for more detailed information. The following table summarizes the default output formats for list-directed output with the intrinsic data types:
*
The READ statement:
*
For formatted list-directed READ statements, formatted internal list-directed READ statements, and formatted namelist READ statements, the field width values and the list-directed semantics are dictated according to the following sample for real constants (N below): For 1 <= N < 10**7, use F15.6 for single precision or F24.15 for double. For N < 1 or N >= 10**7, use E15.6E2 for single precision or E24.15E3 for double. See the Fortran PowerStation documentation for more detailed information about the other data types affected.
*
For unformatted READ statements, the unformatted file semantics are dictated according to the Fortran PowerStation documentation; these semantics are different from the Intel Fortran file format. See the Fortran PowerStation documentation for more detailed information.
fpscomp nolibs
Prevents the portability library from being passed to the linker.
fpscomp ldio_spacing
Specifies that at run time 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.
fpscomp logicals
Specifies that integers with a non-zero value are treated as true, integers with a zero value are treated as false. The literal constant .TRUE. has an integer value of 1, and the literal constant .FALSE. has an integer value of 0. 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 (low bit one) are treated as true and even integer values (low bit zero) are treated as false.
The literal constant .TRUE. has an integer value of -1, and the literal constant .FALSE. has an integer value of 0. This representation is used by Compaq* Visual Fortran. The internal representation of LOGICAL values is not specified by the Fortran standard. Programs which use integer values in LOGICAL contexts, or which pass LOGICAL values to procedures written in other languages, are non-portable and may not execute correctly. Intel recommends that you avoid coding practices that depend on the internal representation of LOGICAL values.
The fpscomp logical option affects the results of all logical expressions and affects the return value for the following Fortran features:
*
The INQUIRE statement specifiers OPENED, IOFOCUS, EXISTS, and NAMED
*
The EOF intrinsic function
*
The BTEST intrinsic function
*
The lexical intrinsic functions LLT, LLE, LGT, and LGE
fpscomp all
Specifies that all options should be used for compatibility with Fortran PowerStation. This is the same as specifying fpscomp with no keyword. Option fpscomp all enables full compatibility with Fortran PowerStation.
Alternate Options:

None

-free
-nofree
Specifies source files are in free format.
Arguments:

None

Default:
OFF
The source file format is determined from the file extension.
Description:

This option specifies source files are in free format. If this option is not specified, format is determined as follows:

*
Files with an extension of .f90, .F90, or .i90 are free-format source files.
*
Files with an extension of .f, .for, .FOR, .ftn, or .i are fixed-format files.
Alternate Options:

Linux and OS X: -FR

-fsource-asm
Produces an assembly listing with source code annotations.
Arguments:

None

Default:
OFF
No source code annotations appear in the assembly listing file, if one is produced.
Description:

This option produces an assembly listing file with source code annotations. The assembly listing file shows the source code as interspersed comments.

To use this option, you must also specify option -S, which causes an assembly listing to be generated.

Alternate Options:

Linux and OS X: None

-fstack-protector[-keyword]
-fno-stack-protector[-keyword]
Enables or disables stack overflow security checks for certain (or all) routines.
Arguments:
keyword
Possible values are:
strong
When option -fstack-protector-strong is specified, it enables stack overflow security checks for routines with any type of buffer.
all
When option -fstack-protector-all is specified, it enables stack overflow security checks for every routine.

If no -keyword is specified, option -fstack-protector enables stack overflow security checks for routines with a string buffer.

Default:
-fno-stack-protector, -fno-stack-protector-strong
No stack overflow security checks are enabled for the relevant routines.
-fno-stack-protector-all
No stack overflow security checks are enabled for any routines.
Description:

This option enables or disables stack overflow security checks for certain (or all) routines. A stack overflow occurs when a program stores more data in a variable on the execution stack than is allocated to the variable. Writing past the end of a string buffer or using an index for an array that is larger than the array bound could cause a stack overflow and security violations.

The -fstack-protector options are provided for compatibility with gcc. They use the gcc/glibc implementation when possible. If the gcc/glibc implementation is not available, they use the Intel implementation.

For an Intel-specific version of this feature, see option -fstack-security-check.

Alternate Options:

None

-fstack-security-check
-fno-stack-security-check
Determines whether the compiler generates code that detects some buffer overruns.
Arguments:

None

Default:
-fno-stack-security-check
The compiler does not detect buffer overruns.
Description:

This option determines whether the compiler generates code that detects some buffer overruns that overwrite the return address. This is a common technique for exploiting code that does not enforce buffer size restrictions.

This option always uses an Intel implementation.

For a gcc-compliant version of this feature, see option fstack-protector.

Alternate Options:

None

-ftrapuv
Initializes stack local variables to an unusual value to aid error detection.
Arguments:

None

Default:
OFF
The compiler does not initialize local variables.
Description:

This option initializes stack local variables to an unusual value to aid error detection. Normally, these local variables should be initialized in the application. It also unmasks the floating-point invalid exception.

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.

This option sets option -g (Linux* OS and OS X*) and /Zi or /Z7 (Windows* OS), which changes the default optimization level from O2 to -O0 (Linux OS and OS X) or /Od (Windows OS). You can override this effect by explicitly specifying an O option setting.

This option sets option [Q]init snan.

If option O2 and option -ftrapuv (Linux OS and OS X) or /Qtrapuv (Windows OS) are used together, you should specify option -fp-speculation safe (Linux OS and OS X) or /Qfp-speculation:safe (Windows OS) to prevent exceptions resulting from speculated floating-point operations from being trapped.

For more details on using options -ftrapuv and /Qtrapuv with compiler option O, see the article in Intel(R) Developer Zone titled Don[aq]t optimize when using -ftrapuv for uninitialized variable detection.

Another way to detect uninitialized local scalar variables is by specifying keyword uninit for option check.

Alternate Options:

None

-ftz
-no-ftz
Flushes denormal results to zero.
Arguments:

None

Default:
-ftz
Denormal results are flushed to zero.
Every optimization option O level, except O0, sets [Q]ftz.
Value 0 for the [Q]fpe option sets [Q]ftz.
Description:

This option 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 your application[aq]s behavior.

The [Q]ftz option has no effect during compile-time optimization.

The [Q]ftz option sets or resets the FTZ and the DAZ hardware flags. If FTZ is ON, denormal results from floating-point calculations will be set to the value zero. If FTZ is OFF, denormal results remain as is. If DAZ is ON, denormal values used as input to floating-point instructions will be treated as zero. If DAZ is OFF, denormal instruction inputs remain as is. Systems using Intel(R) 64 architecture have both FTZ and DAZ. FTZ and DAZ are not supported on all IA-32 architectures.

When the [Q]ftz option is used in combination with an SSE-enabling option on systems using IA-32 architecture (for example, the [Q]xSSE2 option), the compiler will insert code in the main routine to set FTZ and DAZ. When [Q]ftz is used without such an option, the compiler will insert code to conditionally set FTZ/DAZ based on a run-time processor check. The negative form of option [Q]ftz will prevent the compiler from inserting any code that might set FTZ or DAZ.

Option [Q]ftz only has an effect when the main program is being compiled. It sets the FTZ/DAZ mode for the process. The initial thread and any threads subsequently created by that process will operate in FTZ/DAZ mode.

If this option produces undesirable results of the numerical behavior of your program, you can turn the FTZ/DAZ mode off by using -no-ftz or /Qftz- in the command line while still benefiting from the O3 optimizations.

NOTE: Option [Q]ftz is a performance option. Setting this option does not guarantee that all denormals in a program are flushed to zero. The option only causes denormals generated at run time to be flushed to zero.

Alternate Options:

None

-fverbose-asm
-fno-verbose-asm
Produces an assembly listing with compiler comments, including options and version information.
Arguments:

None

Default:
-fno-verbose-asm
No source code annotations appear in the assembly listing file, if one is produced.
Description:

This option produces an assembly listing 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 -fno-verbose-asm.

Alternate Options:

None

-fvisibility=keyword
-fvisibility-keyword=filename
Specifies the default visibility for global symbols or the visibility for symbols in a file.
Arguments:
keyword
Specifies the visibility setting. Possible values are:
default
Sets visibility to default.
extern
Sets visibility to extern.
hidden
Sets visibility to hidden.
internal
Sets visibility to internal.
protected
Sets visibility to protected. This value is not available on OS X* systems.
filename
Is the pathname of a file containing the list of symbols whose visibility you want to set. The symbols must be separated by whitespace (spaces, tabs, or newlines).
Default:
-fvisibility=default
The compiler sets visibility of symbols to default.
Description:

This option specifies the default visibility for global symbols (syntax -fvisibility=keyword) or the visibility for symbols in a file (syntax -fvisibility-keyword=filename).

Visibility specified by -fvisibility-keyword=filename overrides visibility specified by -fvisibility=keyword for symbols specified in a file.

Option
Description
-fvisibility=default -fvisibility-default=filename
Sets visibility of symbols to default. This 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.
-fvisibility=extern -fvisibility-extern=filename
Sets visibility of symbols to extern. This 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.
-fvisibility=hidden -fvisibility-hidden=filename
Sets visibility of symbols to hidden. This means that other components cannot directly reference the symbol. However, its address may be passed to other components indirectly.
-fvisibility=internal -fvisibility-internal=filename
Sets visibility of symbols to internal. This means that the symbol cannot be referenced outside its defining component, either directly or indirectly. The affected functions can never be called from another module, including through function pointers.
-fvisibility=protected -fvisibility-protected=filename
Sets visibility of symbols to protected. This means other components can reference the symbol, but it cannot be overridden by a definition of the same name in another component. This value is not available on OS X* systems.

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

If a symbol appears in more than one visibility filename, the setting with the least visibility takes precedence.

The following shows the precedence of the visibility settings (from greatest to least visibility):

*
extern
*
default
*
protected
*
hidden
*
internal

Note that extern visibility only applies to functions. If a variable symbol is specified as extern, it is assumed to be default.

Alternate Options:

None

-fzero-initialized-in-bss
-fno-zero-initialized-in-bss
Determines whether the compiler places in the DATA section any variables explicitly initialized with zeros.
Arguments:

None

Default:
-fno-zero-initialized-in-bss
Variables explicitly initialized with zeros are placed in the BSS section. This can save space in the resulting code.
Description:

This option determines whether the compiler places in the DATA section any variables explicitly initialized with zeros.

If option -fno-zero-initialized-in-bss (Linux* OS and OS X*) or /Qzero-initialized-in-bss- (Windows* OS) is specified, the compiler places in the DATA section any variables that are initialized to zero.

Alternate Options:

None

-g
Tells the compiler to generate full debugging information in the object file or a project database (PDB) file.
Arguments:

None

Default:
OFF
No debugging information is produced in the object file or in a PDB file.
Description:

Options -g (Linux* OS and OS X*) and /Z7 (Windows* OS) tell the compiler to generate symbolic debugging information in the object file, which increases the size of the object file. The /Zi option (Windows OS) tells the compiler to generate symbolic debugging information in a PDB file.

Two PDB files are created, one by the compiler, and one by the linker:

*
vcx0.pdb, where x represents the version of Visual C++, for example vc100.pdb. This file stores all debugging information for the individual OBJ files and resides in the same directory as the project makefile. If you want to change this name, use option /Fd.
*
executablename.pdb This file stores all debug information for the .exe file and resides in the debug subdirectory.

Each time it creates a .obj file, the compiler merges debug information into vcx0.pdb.

The linker creates executablename.pdb, which contains debug information for the project[aq]s .exe file. The executablename.pdb file contains full debug information, including function prototypes, not just the type information found in vcx0.pdb. Both PDB files allow incremental updates. The linker also embeds the path to the .pdb file in the .exe or .dll file that it creates.

The compiler does not support the generation of debugging information in assemblable files. If you specify these options, the resulting object file will contain debugging information, but the assemblable file will not.

These options turn off O2 and make O0 (Linux OS and OS X) or Od (Windows OS) the default unless O2 (or higher) is explicitly specified in the same command line.

On Linux* OS and OS X*, specifying the -g or -O0 option sets the -fno-omit-frame-pointer option. On Linux* OS, the -debug inline-debug-info option will be enabled by default if you compile with optimizations (option -O2 or higher) and debugging is enabled (option -g).

NOTE: When option -g is specified, debugging information is generated in the DWARF Version 3 format. Older versions of some analysis tools may require applications to be built with the -gdwarf-2 option to ensure correct operation.

Alternate Options:
/Zi
Linux and OS X: None
-gcc-name=name (L*X only)
Lets you specify the name of the gcc compiler that should be used to set up the link-time environment, including the location of standard libraries.
Arguments:
name
Is the name of the gcc compiler to use. It can include the path where the gcc compiler is located.
Default:
OFF
The compiler uses the PATH setting to find the gcc compiler and resolve environment settings.
Description:

This option lets you specify the name of the gcc compiler that should be used to set up the link-time environment, including the location of standard libraries. If you do not specify a path, the compiler will search the PATH settings for the compiler name you provide.

This option is helpful when you are referencing a non-standard gcc installation, or you have multiple gcc installations on your system. The compiler will match gcc version values to the gcc compiler you specify.

The C++ equivalent to option -gcc-name is -gxx-name.

Alternate Options:

None

-gdwarf-n
Lets you specify a DWARF Version format when generating debug information.
Arguments:
n
Is a value denoting the DWARF Version format to use. Possible values are:
2
Generates debug information using the DWARF Version 2 format.
3
Generates debug information using the DWARF Version 3 format.
4
Generates debug information using the DWARF Version 4 format. This setting is only available on Linux* OS.
Default:
OFF
No debug information is generated. However, if compiler option -g is specified, debugging information is generated in the DWARF Version 3 format.
Description:

This option lets you specify a DWARF Version format when generating debug information.

Note that older versions of some analysis tools may require applications to be built with the -gdwarf-2 option to ensure correct operation.

Alternate Options:

None

-gen-dep[=filename]
-no-gen-dep
Tells the compiler to generate build dependencies for the current compilation.
Arguments:
filename
Is the name of the file for output. It can include a path.
If you specify filename, it is similar to specifying option [Q]MFfilename. If you do not specify filename, it is similar to specifying option [Q]MD or [Q]MMD.
Default:
-no-gen-dep or /gen-dep-
The compiler does not generate build dependencies for the compilation.
Description:

This option tells the compiler to generate build dependencies for the current compilation. The build dependencies include a list of all files included with INCLUDE statements or .mod files accessed with USE statements.

If you do not specify filename, the dependencies are written to stdout.

You can use option gen-depformat to specify the form of the output for the build dependencies generated.

If you specify option gen-dep and you do not specify option gen-depformat, the output format is in a form acceptable to the make utility.

Note that if option fpp is used to process #include files, those files will also appear in the list of build dependencies.

If you want to generate build dependencies but you do not want to compile the sources, you must also specify option syntax-only.

Alternate Options:
gen-dep with a filename
Linux and OS X: -MF
gen-dep with no filename
Linux and OS X: -MD or -MMD
-gen-depformat=form
Specifies the form for the output generated when option gen-dep is specified.
Arguments:
form
Is the output form for the list of build dependencies. Possible values are make or nmake.
Default:
make
The output form for the list of build dependencies is in a form acceptable to the make utility.
Description:

This option specifies the form for the output generated when option gen-dep is specified.

If you specify option gen-depformat and do not specify option gen-dep, the option is ignored.

Alternate Options:

None

-gen-depshow=keyword
Determines whether certain features are excluded from dependency analysis. Currently, it only applies to intrinsic modules.
Arguments:
keyword
Specifies inclusion or exclusion from dependency analysis. Possible values are:
[no]intr_mod
Determines whether intrinsic modules are excluded from dependency analysis.
Default:
nointr_mod
Tells the compiler to exclude Fortran intrinsic modules in dependency analysis.
Description:

This option determines whether certain features are excluded from dependency analysis. Currently, it only applies to intrinsic modules.

Option
Description
gen-depshow intr_mod
Tells the compiler to include Fortran intrinsic modules in dependency analysis.

If you do not specify option gen-dep, the compiler does not generate build dependencies for the compilation.

If you specify option gen-depshow and do not specify option gen-dep, the option is ignored.

Alternate Options:
gen-depshow nointr_mod
Linux and OS X: -MMD
-gen-interfaces [[no]source]
-nogen-interfaces
Tells the compiler to generate an interface block for each routine in a source file.
Arguments:

None

Default:
nogen-interfaces
The compiler does not generate interface blocks for routines in a source file.
Description:

This option 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 .f90 file is for reference only and may not completely represent the generated interface used by the compiler.

If source is specified, the compiler creates the procedure-name__GENmod.f90 as well as the procedure-name__GENmod.mod files. If nosource is specified, the compiler creates the procedure-name__GENmod.mod but not the procedure-name__GENmod.f90 files. If neither is specified, it is the same as specifying setting source for the gen-interfaces option.

On Windows* OS, for a Debug configuration in a Visual Studio project, the default is /warn:interfaces.

Alternate Options:

None

-global-hoist
-no-global-hoist
Enables certain optimizations that can move memory loads to a point earlier in the program execution than where they appear in the source.
Arguments:

None

Default:
-global-hoist
Certain optimizations are enabled that can move memory loads.
Description:

This option enables certain optimizations that can move memory loads to a point earlier in the program execution than where they appear in the source. In most cases, these optimizations are safe and can improve performance.

The negative form of the 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).

Alternate Options:

None

-grecord-gcc-switches (L*X only)
Causes the command line options that were used to invoke the compiler to be appended to the DW_AT_producer attribute in DWARF debugging information.
Arguments:

None

Default:
OFF
The command line options that were used to invoke the compiler are not appended to the DW_AT_producer attribute in DWARF debugging information.
Description:

This option causes the command line options that were used to invoke the compiler to be appended to the DW_AT_producer attribute in DWARF debugging information.

The options are concatenated with whitespace separating them from each other and from the compiler version.

Alternate Options:

None

-gsplit-dwarf (L*X only)
Creates a separate object file containing DWARF debug information.
Architectures: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
No separate object file containing DWARF debug information is created.
Description:

This option creates a separate object file containing DWARF debug information. It causes debug information to be split between the generated object (.o) file and the new DWARF object (.dwo) file.

The DWARF object file is not used by the linker, so this reduces the amount of debug information the linker must process and it results in a smaller executable file.

For this option to perform correctly, you must use binutils-2.24 or later. To debug the resulting executable, you must use gdb-7.6.1 or later.

NOTE: If you use the split executable with a tool that does not support the split DWARF format, it will behave as though the DWARF debug information is absent.

Alternate Options:

None

-guide[=n]
Lets you set a level of guidance for auto-vectorization, auto parallelism, and data transformation.
Arguments:
n
Is an optional value specifying the level of guidance to be provided.
The values available are 1 through 4. Value 1 indicates a standard level of guidance. Value 4 indicates the most advanced level of guidance. If n is omitted, the default is 4.
Default:
OFF
You do not receive guidance about how to improve optimizations for parallelism, vectorization, and data transformation.
Description:

This option lets you set a level of guidance (advice) for auto-vectorization, auto parallelism, and data transformation. It causes the compiler to generate messages suggesting ways to improve these optimizations.

When this option is specified, the compiler does not produce any objects or executables.

You must also specify the [Q]parallel option to receive auto parallelism guidance.

You can set levels of guidance for the individual guide optimizations by specifying one of the following options:

[Q]guide-data-trans
Provides guidance for data transformation.
[Q]guide-par
Provides guidance for auto parallelism.
[Q]guide-vec
Provides guidance for auto-vectorization.

If you specify the [Q]guide option and also specify one of the options setting a level of guidance for an individual guide optimization, the value set for the individual guide optimization will override the setting specified in [Q]guide.

If you do not specify [Q]guide, but specify one of the options setting a level of guidance for an individual guide optimization, option [Q]guide is enabled with the greatest value passed among any of the three individual guide optimizations specified.

In debug mode, this option has no effect unless option O2 (or higher) is explicitly specified in the same command line.

NOTE: The compiler speculatively performs optimizations as part of guide analysis. As a result, when you use guided auto-parallelism options with options that produce vectorization or auto-parallelizer reports (such as option [q or Q]opt-report), the compiler generates "LOOP WAS VECTORIZED" or similar messages as if the compilation was performed with the recommended changes.

When compilation is performed with the [Q]guide option, you should use extra caution when interpreting vectorizer diagnostics and auto-parallelizer diagnostics.

NOTE: You can specify [Q]diag-disable to prevent the compiler from issuing one or more diagnostic messages.

Alternate Options:

None

-guide-data-trans[=n]
Lets you set a level of guidance for data transformation.
Arguments:
n
Is an optional value specifying the level of guidance to be provided.
The values available are 1 through 4. Value 1 indicates a standard level of guidance. Value 4 indicates the most advanced level of guidance. If n is omitted, the default is 4.
Default:
OFF
You do not receive guidance about how to improve optimizations for data transformation.
Description:

This option lets you set a level of guidance for data transformation. It causes the compiler to generate messages suggesting ways to improve that optimization.

Alternate Options:

None

-guide-file[=filename]
Causes the results of guided auto parallelism to be output to a file.
Arguments:
filename
Is the name of the file for output. It can include a path.
Default:
OFF
Messages that are generated by guided auto parallelism are output to stderr.
Description:

This option causes the results of guided auto parallelism to be output to a file.

This option is ignored unless you also specify one or more of the following options:

*
[Q]guide
*
[Q]guide-vec
*
[Q]guide-data-trans
*
[Q]guide-par

If you do not specify a path, the file is placed in the current working directory.

If there is already a file named filename, it will be overwritten.

You can include a file extension in filename. For example, if file.txt is specified, the name of the output file is file.txt. If you do not provide a file extension, the name of the file is filename.guide.

If you do not specify filename, the name of the file is name-of-the-first-source-file.guide. This is also the name of the file if the name specified for filename conflicts with a source file name provided in the command line.

NOTE: If you specify the [Q]guide-file option and you also specify option [Q]guide-file-append, the last option specified on the command line takes precedence.

Alternate Options:

None

-guide-file-append[=filename]
Causes the results of guided auto parallelism to be appended to a file.
Arguments:
filename
Is the name of the file to be appended to. It can include a path.
Default:
OFF
Messages that are generated by guided auto parallelism are output to stderr.
Description:

This option causes the results of guided auto parallelism to be appended to a file.

This option is ignored unless you also specify one or more of the following options:

*
[Q]guide
*
[Q]guide-vec
*
[Q]guide-data-trans
*
[Q]guide-par

If you do not specify a path, the compiler looks for filename in the current working directory.

If filename is not found, then a new file with that name is created in the current working directory.

If you do not specify a file extension, the name of the file is filename.guide.

If the name specified for filename conflicts with a source file name provided in the command line, the name of the file is name-of-the-first-source-file.guide.

NOTE: If you specify the [Q]guide-file-append option and you also specify option [Q]guide-file, the last option specified on the command line takes precedence.

Alternate Options:

None

-guide-opts=string
Tells the compiler to analyze certain code and generate recommendations that may improve optimizations.
Arguments:
string
Is the text denoting the code to analyze. The string must appear within quotes. It can take one or more of the following forms: filenamefilename, routinefilename, range [, range]... filename, routine, range [, range]...
If you specify more than one of the above forms in a string, a semicolon must appear between each form. If you specify more than one range in a string, a comma must appear between each range. Optional blanks can follow each parameter in the forms above and they can also follow each form in a string.
filename
Specifies the name of a file to be analyzed. It can include a path.
If you do not specify a path, the compiler looks for filename in the current working directory.
routine
Specifies the name of a routine to be analyzed. You can include an identifying argument.
The name, including any argument, must be enclosed in single quotes.
The compiler tries to uniquely identify the routine that corresponds to the specified routine name. It may select multiple routines to analyze, especially if the following is true:
*
More than one routine has the specified routine name, so the routine cannot be uniquely identified.
*
No argument information has been specified to narrow the number of routines selected as matches.
range
Specifies a range of line numbers to analyze in the file or routine specified. The range must be specified in integers in the form:
first_line_number-last_line_number
The hyphen between the line numbers is required.
Default:
OFF
You do not receive guidance on how to improve optimizations. However, if you specify the [Q]guide option, the compiler analyzes and generates recommendations for all the code in an application
Description:

This option tells the compiler to analyze certain code and generate recommendations that may improve optimizations.

This option is ignored unless you also specify one or more of the following options:

*
[Q]guide
*
[Q]guide-vec
*
[Q]guide-data-trans
*
[Q]guide-par

When the [Q]guide-opts option is specified, a message is output that includes which parts of the input files are being analyzed. If a routine is selected to be analyzed, the complete routine name will appear in the generated message.

When inlining is involved, you should specify callee line numbers. Generated messages also use callee line numbers.

Alternate Options:

None

-guide-par[=n]
Lets you set a level of guidance for auto parallelism.
Arguments:
n
Is an optional value specifying the level of guidance to be provided.
The values available are 1 through 4. Value 1 indicates a standard level of guidance. Value 4 indicates the most advanced level of guidance. If n is omitted, the default is 4.
Default:
OFF
You do not receive guidance about how to improve optimizations for parallelism.
Description:

This option lets you set a level of guidance for auto parallelism. It causes the compiler to generate messages suggesting ways to improve that optimization.

You must also specify the [Q]parallel option to receive auto parallelism guidance.

Alternate Options:

None

-guide-profile=filename|dir [, [filename|dir]...]
Specifies a loop profiler data file (or a set of files) when used with option -guide or /Qguide.
Arguments:
filename
Is an .xml file created from a loop profiler run.
dir
Is a directory that contains one or more .xml files from a loop profiler run.
Default:
OFF
When the [Q]guide option is specified, the guide region is the whole file or the region specified by option [Q]guide-opts.
Description:

This option specifies a loop profiler data file (or a set of files) when used with the [Q]guide option.

This option has no effect unless the [Q]guide option has been specified. Option [Q]guide-profile helps you take advantage of the [Q]guide option to more efficiently optimize your applications for auto parallelism and/or vectorization.

The loop profile data file can be collected by using one of the following options:

*
[Q]profile-loops
*
[Q]profile-functions

When the data is from [Q]profile-loops, the setting of the guide regions will be based upon the hottest loops.

When the data is from [Q]profile-functions, the guide region will be the entire function containing the hottest functions.

If you specify options [Q]guide-opts and [Q]guide-profile, the compiler issues an error message.

Alternate Options:

None

-guide-vec[=n]
Lets you set a level of guidance for auto-vectorization.
Arguments:
n
Is an optional value specifying the level of guidance to be provided.
The values available are 1 through 4. Value 1 indicates a standard level of guidance. Value 4 indicates the most advanced level of guidance. If n is omitted, the default is 4.
Default:
OFF
You do not receive guidance about how to improve optimizations for vectorization.
Description:

This option lets you set a level of guidance for auto-vectorization. It causes the compiler to generate messages suggesting ways to improve that optimization.

Alternate Options:

None

-gxx-name=name (L*X only)
Lets you specify the name of the g++ compiler that should be used to set up the link-time environment, including the location of standard libraries.
Arguments:
name
Is the name of the g++ compiler to use. It can include the path where the g++ compiler is located.
Default:
OFF
The compiler uses the PATH setting to find the g++ compiler and resolve environment settings.
Description:

This option lets you specify the name of the g++ compiler that should be used to set up the link-time environment, including the location of standard libraries. If you do not specify a path, the compiler will search the PATH settings for the compiler name you provide.

This option is helpful if you have multiple gcc++ installations on your system. The compiler will match gcc++ version values to the gcc++ compiler you specify.

The C equivalent to option -gxx-name is -gcc-name.

NOTE: When compiling a C++ file with icc, g++ is used to get the environment.

Alternate Options:

None

-heap-arrays [size]
-no-heap-arrays
Puts automatic arrays and arrays created for temporary computations on the heap instead of the stack.
Arguments:
size
Is an integer value representing the size of the arrays in kilobytes. Arrays smaller than size are put on the stack.
Default:
-no-heap-arrays
The compiler puts automatic arrays and temporary arrays in the stack storage area.
Description:

This option puts automatic arrays and arrays created for temporary computations on the heap instead of the stack.

When this option is specified, automatic (temporary) arrays that have a compile-time size greater than the value specified for size are put on the heap, rather than on the stack. If the compiler cannot determine the size at compile time, it always puts the automatic array on the heap.

If size is specified, the value is only used when the total size of the temporary array or automatic array can be determined at compile time, using compile-time constants. Any arrays known at compile-time to be larger than size are allocated on the heap instead of the stack. For example, if 10 is specified for size:

*
All automatic and temporary arrays equal to or larger than 10 KB are put on the heap.
*
All automatic and temporary arrays smaller than 10 KB are put on the stack.

If size is omitted, and the size of the temporary array or automatic array cannot be determined at compile time, it is assumed that the total size is greater than size and the array is allocated on the heap.

Alternate Options:

None

-help[category]
Displays all available compiler options or a category of compiler options.
Arguments:
category
Is a category or class of options to display. Possible values are:
advanced
Displays advanced optimization options that allow fine tuning of compilation or allow control over advanced features of the compiler.
codegen
Displays Code Generation options.
compatibility
Displays options affecting language compatibility.
component
Displays options for component control.
data
Displays options related to interpretation of data in programs or the storage of data.
deprecated
Displays options that have been deprecated.
diagnostics
Displays options that affect diagnostic messages displayed by the compiler.
float
Displays options that affect floating-point operations.
help
Displays all the available help categories.
inline
Displays options that affect inlining.
ipo
Displays Interprocedural Optimization (IPO) options
language
Displays options affecting the behavior of the compiler language features.
link
Displays linking or linker options.
misc
Displays miscellaneous options that do not fit within other categories.
openmp
Displays OpenMP and parallel processing options.
opt
Displays options that help you optimize code.
output
Displays options that provide control over compiler output.
pgo
Displays Profile Guided Optimization (PGO) options.
preproc
Displays options that affect preprocessing operations.
reports
Displays options for optimization reports.
Default:
OFF
No list is displayed unless this compiler option is specified.
Description:

This option displays all available compiler options or a category of compiler options. If category is not specified, all available compiler options are displayed.

Alternate Options:

Linux and OS X: None

-Idir
Specifies an additional directory for the include path.
Arguments:
dir
Is the directory to add to the include path.
Default:
OFF
The default include path is used.
Description:

This option specifies an additional directory for the include path, which is searched for module files referenced in USE statements and include files referenced in INCLUDE statements. To specify multiple directories on the command line, repeat the option for each directory you want to add.

For all USE statements and for those INCLUDE statements whose file name does not begin with a device or directory name, the directories are searched in this order:

1)
The directory containing the first source file.
Note that if assume nosource_include is specified, this directory will not be searched.
2)
The current working directory where the compilation is taking place (if different from the above directory).
3)
Any directory or directories specified using the I option. If multiple directories are specified, they are searched in the order specified on the command line, from left to right.
4)
On Linux* and OS X* systems, any directories indicated using environment variable CPATH. On Windows* systems, any directories indicated using environment variable INCLUDE.

This option affects fpp preprocessor behavior and the USE statement.

Alternate Options:

Linux and OS X: None

-idirafterdir
Adds a directory to the second include file search path.
Arguments:
dir
Is the name of the directory to add.
Default:
OFF
Include file search paths include certain default directories.
Description:

This option adds a directory to the second include file search path (after -I).

Alternate Options:

None

Tells the compiler to link to the IMSL* Fortran Numerical Library*(IMSL* library).
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
The compiler does not link to the IMSL* library.
Description:

This option tells the compiler to link to the IMSL* Fortran Numerical Library* (IMSL* library). This option is applicable for users of editions of the Intel(R) Fortran Compiler product that include the IMSL* libraries.

This option is processed by the compiler, which adds directives to the compiled object file that are processed by the linker.

Alternate Options:

None

-init=keyword
Lets you initialize a class of variables
to zero or to signaling NaN.
Architecture Restrictions: [Q]init keyword snan: Not available on Intel(R) 64
architecture targeting the Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
keyword
Specifies the initial value for a class of variables. Possible values are:
[no]arrays
Determines whether the compiler initializes variables that are arrays or scalars. Specifying arrays initializes variables that are arrays or scalars. Specifying noarrays initializes only variables that are scalars. You must also specify either [Q]init snan or [Q]init zero when you specify [Q]init [no]arrays.
[no]snan
Determines whether the compiler initializes to signaling NaN all uninitialized variables of intrinsic type REAL or COMPLEX that are saved, local, automatic, or allocated variables.
[no]zero
Determines whether the compiler initializes to zero all uninitialized variables of intrinsic type REAL, COMPLEX, INTEGER, or LOGICAL that are saved, local, automatic, or allocated variables.
Option /Qinit:[no]zero replaces option /Qzero[-] (Windows*) , and option -init=[no]zero replaces option -[no]zero (Linux* and OS X*).
Default:
OFF
No initializations are performed by default if you do not specify any of these options.
Description:

This option lets you initialize a class of variables to zero or to signaling NaN.

If you only specify option -init=zero or -init=snan (Linux* OS and OS X*) or /Qinit:zero or /Qinit:snan (Windows* OS), it affects only scalar variables. To apply the initialization to arrays as well, you must also specify option -init=arrays (Linux* OS and OS X*) or Qinit:arrays (Windows* OS).

If you specify both [Q]init snan and [Q]init zero, then certain variables of REAL and COMPLEX type are initialized to signaling NaN and certain variables of INTEGER and LOGICAL type are initialized to zero.

The following classes of variables are affected by the [Q]init option:

*
Variables of intrinsic numeric type, that is, of type COMPLEX, INTEGER, LOGICAL, or REAL, of any KIND
*
SAVEd scalar or array variables, not in the main program, that are not initialized in the source code
*
Local scalars and arrays
*
Module variables that are not initialized in the source code
*
Automatic arrays
*
Variables with the POINTER or ALLOCATABLE attribute
*
In a user-defined type, components that have the POINTER or ALLOCATABLE attribute may be initialized with option [Q]init

The following are general restrictions for this option:

*
[Q]init snan only affects certain variables of REAL or COMPLEX type.
*
You cannot initialize variables in equivalence groups to signaling NaN values.
*
In an equivalence group, if no member of that equivalence group has an explicit initialization or a default initialization (in the case of a derived type), a variable in that equivalence group can be initialized to zero.
*
Derived types, arrays of derived types, and their components will not be initialized.
*
Dummy arguments including adjustable arrays will not be initialized.
*
Variables in COMMON will not be initialized.

If you specify [Q]init snan, the floating-point exception handling flags will be set to trap signaling NaN and halt so that when such a value is trapped at run-time, the Fortran library can catch the usage, display an error message about a possible uninitialized variable, display a traceback, and stop execution. You can use the debugger to determine where in your code this uninitialized variable is being referenced when execution stops.

Setting the option [Q]init snan implicitly sets the option fpe 0. A compile time warning will occur if you specify both option fpe 3 and option [Q]init snan on the command line. In this case, fpe 3 is ignored.

NOTE: If you build with optimization, the compiler may speculate floating-point operations, assuming the default floating-point environment in which floating-point exceptions are masked. When you add [Q]init snan, this speculation may result in exceptions, unrelated to uninitialized variables, that now get trapped. To avoid this, reduce the optimization level to /O1 or /Od (Windows*), or -O1 or -O0 (Linux* and OS X*) when doing uninitialized variable detection.

If you wish to maintain optimization, you should add option [Q]fp-speculation safe to disable speculation when there is a possibility that the speculation may result in a floating-point exception.

On Intel(R) 64 architecture targeting the Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner), you cannot specify [Q]init [no]snan, since trapping signaling snan is not available.

Use option [Q]save if you wish all variables to be specifically marked as SAVE.

Alternate Options:

None

-inline-factor=n
-no-inline-factor
Specifies the percentage multiplier that should be applied to all inlining options that define upper limits.
Arguments:
n
Is a positive integer specifying the percentage value. The default value is 100 (a factor of 1).
Default:
-inline-factor=100
The compiler uses a percentage multiplier of 100.
Description:

This option specifies the percentage multiplier that should be applied to all inlining options that define upper limits:

*
[Q]inline-max-size
*
[Q]inline-max-total-size
*
[Q]inline-max-per-routine
*
[Q]inline-max-per-compile

The [Q]inline-factor 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. This option is useful if you do not want to individually increase each option limit.

If you specify -no-inline-factor (Linux* OS and OS X*) or /Qinline-factor- (Windows* OS), 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.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase default limits, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-forceinline
Instructs the compiler to force inlining of functions suggested for inlining whenever the compiler is capable doing so.
Default:
OFF
The compiler uses default heuristics for inline routine expansion.
Description:

This option instructs the compiler to force inlining of functions suggested for inlining whenever the compiler is capable doing so.

Without this option, the compiler treats functions declared with an INLINE attribute as merely being recommended for inlining. When this option is used, it is as if they were declared with the directive !DIR$ ATTRIBUTES FORCEINLINE.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to change the meaning of inline to "forceinline", the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-level=n
Specifies the level of inline function expansion.
Arguments:
n
Is the inline function expansion level. Possible values are 0, 1, and 2.
Default:
-inline-level=2
This is the default if option O2 is specified or is in effect by default. On Windows* systems, this is also the default if option O3 is specified.
-inline-level=0
This is the default if option -O0 (Linux* OS and OS X*) is specified.
Description:

This option specifies the level of inline function expansion. Inlining procedures can greatly improve the run-time performance of certain programs.

Option
Description
-inline-level=0 or /Ob0
Disables inlining of user-defined functions. Note that statement functions are always inlined.
-inline-level=1 or /Ob1
Enables inlining when an inline keyword or an inline directive is specified.
-inline-level=2 or /Ob2
Enables inlining of any function at the compiler[aq]s discretion.
Alternate Options:

None

-inline-max-per-compile=n
-no-inline-max-per-compile
Specifies the maximum number of times inlining may be applied to an entire compilation unit.
Arguments:
n
Is a positive integer that specifies the number of times inlining may be applied.
Default:
-no-inline-max-per-compile
The compiler uses default heuristics for inline routine expansion.
Description:

This option the maximum number of times inlining may be applied to an entire compilation unit. It limits the number of times that inlining can be applied.

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 (Linux* OS and OS X*) or /Qinline-max-per-compile- (Windows* OS), there is no limit to the number of times inlining may be applied to a compilation unit.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase the default limit, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-max-per-routine=n
-no-inline-max-per-routine
Specifies the maximum number of times the inliner may inline into a particular routine.
Arguments:
n
Is a positive integer that specifies the maximum number of times the inliner may inline into a particular routine.
Default:
-no-inline-max-per-routine
The compiler uses default heuristics for inline routine expansion.
Description:

This option specifies the maximum number of times the inliner may inline into a particular routine. It limits the number of times that inlining can be applied to any routine.

If you specify -no-inline-max-per-routine (Linux* OS and OS X*) or /Qinline-max-per-routine- (Windows* OS), there is no limit to the number of times some routine may be inlined into a particular routine.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase the default limit, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-max-size=n
-no-inline-max-size
Specifies the lower limit for the size of what the inliner considers to be a large routine.
Arguments:
n
Is a positive integer that specifies the minimum size of what the inliner considers to be a large routine.
Default:
-inline-max-size
The compiler sets the maximum size (n) dynamically, based on the platform.
Description:

This option specifies the lower limit for the size of what the inliner considers to be a large routine (a function or subroutine). The inliner classifies routines as small, medium, or large. This option specifies the boundary between what the inliner considers to be medium and large-size routines.

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 (Linux* OS and OS X*) or /Qinline-max-size- (Windows* OS), there are no large routines. Every routine is either a small or medium routine.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase the default limit, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-max-total-size=n
-no-inline-max-total-size
Specifies how much larger a routine can normally grow when inline expansion is performed.
Arguments:
n
Is a positive integer that specifies the permitted increase in the routine[aq]s size when inline expansion is performed.
Default:
-no-inline-max-total-size
The compiler uses default heuristics for inline routine expansion.
Description:

This option specifies how much larger a routine can normally grow when inline expansion is performed. It limits the potential size of the routine. For example, if 2000 is specified for n, the size of any routine will normally not increase by more than 2000.

If you specify -no-inline-max-total-size (Linux* OS and OS X*) or /Qinline-max-total-size- (Windows* OS), there is no limit to the size a routine may grow when inline expansion is performed.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase the default limit, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-inline-min-size=n
-no-inline-min-size
Specifies the upper limit for the size of what the inliner considers to be a small routine.
Arguments:
n
Is a positive integer that specifies the maximum size of what the inliner considers to be a small routine.
Default:
-no-inline-min-size
The compiler uses default heuristics for inline routine expansion.
Description:

This option specifies the upper limit for the size of what the inliner considers to be a small routine (a function or subroutine). The inliner classifies routines as small, medium, or large. This option specifies the boundary between what the inliner considers to be small and medium-size routines.

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 (Linux* OS and OS X*) or /Qinline-min-size- (Windows* OS), there is no limit to the size of small routines. Every routine is a small routine; there are no medium or large routines.

To see compiler values for important inlining limits, specify option [q or Q]opt-report.

CAUTION: When you use this option to increase the default limit, the compiler may do so much additional inlining that it runs out of memory and terminates with an "out of memory" message.

Alternate Options:

None

-intconstant
-nointconstant
Tells the compiler to use FORTRAN 77 semantics to determine the kind parameter for integer constants.
Arguments:

None

Default:
nointconstant
The compiler uses the Fortran 2003 default INTEGER type.
Description:

This option tells the compiler to use FORTRAN 77 semantics to determine the kind parameter for integer constants.

With FORTRAN 77 semantics, the kind is determined by the value of the constant. All constants are kept internally by the compiler in the highest precision possible. For example, if you specify option intconstant, the compiler stores an integer constant of 14 internally as INTEGER(KIND=8) and converts the constant upon reference to the corresponding proper size. Fortran 2003 specifies that integer constants with no explicit KIND are kept internally in the default INTEGER kind (KIND=4 by default).

Note that the internal precision for floating-point constants is controlled by option fpconstant.

Alternate Options:

None

-integer-size size
Specifies the default KIND for integer and logical variables.
Arguments:
size
Is the size for integer and logical variables. Possible values are: 16, 32, or 64.
Default:
integer-size 32
Integer and logical variables are 4 bytes long (INTEGER(KIND=4) and LOGICAL(KIND=4)).
Description:

This option specifies the default size (in bits) for integer and logical variables.

Option
Description
integer-size 16
Makes default integer and logical declarations, constants, functions, and intrinsics 2 bytes long. INTEGER and LOGICAL declarations are treated as (KIND=2). Integer and logical constants of unspecified KIND are evaluated in INTEGER (KIND=2) and LOGICAL(KIND=2)respectively.
integer-size 32
Makes default integer and logical declarations, constants, functions, and intrinsics 4 bytes long. INTEGER and LOGICAL declarations are treated as (KIND=4). Integer and logical constants of unspecified KIND are evaluated in INTEGER (KIND=4) and LOGICAL(KIND=4)respectively.
integer-size 64
Makes default integer and logical declarations, constants, functions, and intrinsics 8 bytes long. INTEGER and LOGICAL declarations are treated as (KIND=8). Integer and logical constants of unspecified KIND are evaluated in INTEGER (KIND=8) and LOGICAL(KIND=8)respectively.
Alternate Options:
integer-size 16
Linux and OS X: -i2
integer-size 32
Linux and OS X: -i4
integer-size 64
Linux and OS X: -i8
-ip
-no-ip
Determines whether additional interprocedural optimizations for single-file compilation are enabled.
Arguments:

None

Default:
OFF
Some limited interprocedural optimizations occur, including inline function expansion for calls to functions defined within the current source file. These optimizations are a subset of full intra-file interprocedural optimizations. Note that this setting is not the same as -no-ip (Linux* OS and OS X*).
Description:

This option determines whether additional interprocedural optimizations for single-file compilation are enabled.

The [Q]ip option enables additional interprocedural optimizations for single-file compilation.

Options -no-ip (Linux OS and OS X) and /Qip- (Windows OS) may not disable inlining. To ensure that inlining of user-defined functions is disabled, specify -inline-level=0or -fno-inline (Linux OS and OS X), or specify /Ob0 (Windows OS).

Alternate Options:

None

-ip-no-inlining
Disables full and partial inlining enabled by interprocedural optimization options.
Arguments:

None

Default:
OFF
Inlining enabled by interprocedural optimization options is performed.
Description:

This option disables full and partial inlining enabled by the following interprocedural optimization options:

*
On Linux* and OS X* systems: -ip or -ipo
*
On Windows* systems: /Qip, /Qipo, or /Ob2

It has no effect on other interprocedural optimizations.

On Windows systems, this option also has no effect on user-directed inlining specified by option /Ob1.

Alternate Options:

None

-ip-no-pinlining
Disables partial inlining enabled by interprocedural optimization options.
Arguments:

None

Default:
OFF
Inlining enabled by interprocedural optimization options is performed.
Description:

This option disables partial inlining enabled by the following interprocedural optimization options:

*
On Linux* and OS X* systems: -ip or -ipo
*
On Windows* systems: /Qip or /Qipo

It has no effect on other interprocedural optimizations.

Alternate Options:

None

-ipo[n]
-no-ipo
Enables interprocedural optimization between files.
Arguments:
n
Is an optional integer that specifies the number of object files the compiler should create. The integer must be greater than or equal to 0.
Default:
-no-ipo or /Qipo-
Multifile interprocedural optimization is not enabled.
Description:

This option enables interprocedural optimization between files. This is also called multifile interprocedural optimization (multifile IPO) or Whole Program Optimization (WPO).

When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files.

You cannot specify the names for the files that are created.

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.

Alternate Options:

None

-ipo-c
Tells the compiler to optimize across multiple files and generate a single object file.
Arguments:

None

Default:
OFF
The compiler does not generate a multifile object file.
Description:

This option tells the compiler to optimize across multiple files and generate a single object file (named ipo_out.o on Linux* and OS X* systems; ipo_out.obj on Windows* systems).

It performs the same optimizations as the [Q]ipo option, but compilation stops before the final link stage, leaving an optimized object file that can be used in further link steps.

Alternate Options:

None

-ipo-jobsn
Specifies the number of commands (jobs) to be executed simultaneously during the link phase of Interprocedural Optimization (IPO).
Arguments:
n
Is the number of commands (jobs) to run simultaneously. The number must be greater than or equal to 1.
Default:
-ipo-jobs1
One command (job) is executed in an interprocedural optimization parallel build.
Description:

This option specifies the number of commands (jobs) to be executed simultaneously during the link phase of Interprocedural Optimization (IPO). It should only be used if the link-time compilation is generating more than one object. In this case, each object is generated by a separate compilation, which can be done in parallel.

This option can be affected by the following compiler options:

*
[Q]ipo when applications are large enough that the compiler decides to generate multiple object files.
*
[Q]ipon when n is greater than 1.
*
[Q]ipo-separate

CAUTION: Be careful when using this option. On a multi-processor system with lots of memory, it can speed application build time. However, if n is greater than the number of processors, or if there is not enough memory to avoid thrashing, this option can increase application build time.

Alternate Options:

None

-ipo-S
Tells the compiler to optimize across multiple files and generate a single assembly file.
Arguments:

None

Default:
OFF
The compiler does not generate a multifile assembly file.
Description:

This option tells the compiler to optimize across multiple files and generate a single assembly file (named ipo_out.s on Linux* and OS X* systems; ipo_out.asm on Windows* systems).

It performs the same optimizations as the [Q]ipo option, but compilation stops before the final link stage, leaving an optimized assembly file that can be used in further link steps.

Alternate Options:

None

-ipo-separate (L*X only)
Tells the compiler to generate one object file for every source file.
Arguments:

None

Default:
OFF
The compiler decides whether to create one or more object files.
Description:

This option tells the compiler to generate one object file for every source file. It overrides any [Q]ipo option specification.

Alternate Options:

None

-isystemdir
Specifies a directory to add to the start of the system include path.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
dir
Is the directory to add to the system include path.
Default:
OFF
The default system include path is used.
Description:

This option specifies a directory to add to 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.

On Linux* systems, this option is provided for compatibility with gcc.

Alternate Options:

None

-lstring
Tells the linker to search for a specified library when linking.
Arguments:
string
Specifies the library (libstring) that the linker should search.
Default:
OFF
The linker searches for standard libraries in standard directories.
Description:

This option tells the linker to search for a specified library when linking.

When resolving references, the linker normally searches for libraries in several standard directories, in directories specified by the L option, then in the library specified by the l option.

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

Alternate Options:

None

-Ldir
Tells the linker to search for libraries in a specified directory before searching the standard directories.
Arguments:
dir
Is the name of the directory to search for libraries.
Default:
OFF
The linker searches the standard directories for libraries.
Description:

This option tells the linker to search for libraries in a specified directory before searching for them in the standard directories.

Alternate Options:

None

-list[=filename]
-no-list
Tells the compiler to create a listing of the source file.
Arguments:
filename
Is the name of the file for output. It can include a path.
Default:
-no-list or /list-
No listing is created for the source file.
Description:

This option tells the compiler to create a listing of the source file. The listing contains the following:

*
The contents of files included with INCLUDE statements
*
A symbol list with a line number cross-reference for each routine
*
A list of compiler options used for the current compilation

The contents of the listing can be controlled by specifying option show.

The line length of the listing can be specified by using option list-line-len.

The page length of the listing can be specified by using option list-page-len.

If you do not specify filename, the output is written to a file in the same directory as the source. The file name is the name of the source file with an extension of .lst.

Alternate Options:

None

-list-line-len=n
Specifies the line length for the listing generated when option list is specified.
Arguments:
n
Is a positive integer indicating the number of columns to show in the listing.
Default:
80
When a listing is generated, the default line length is 80 columns.
Description:

This option specifies the line length for the listing generated when option list is specified.

If you specify option list-line-len and do not specify option list, the option is ignored.

Alternate Options:

None

-list-page-len=n
Specifies the page length for the listing generated when option list is specified.
Arguments:
n
Is a positive integer indicating the number of lines on a page to show in the listing.
Default:
60
When a listing is generated, the default page length is 60 lines.
Description:

This option specifies the page length for the listing generated when option list is specified.

If you specify option list-page-len and do not specify option list, the option is ignored.

Alternate Options:

None

-logo
-nologo
Displays the compiler version information.
Arguments:

None

Default:
Linux* OS and OS X*: nologo
The compiler version information is not displayed.
Description:

This option displays the startup banner, which contains the following compiler information:

*
The name of the compiler and its applicable architecture
*
The major and minor version of the compiler, the update number, and the package number(for example, Version 11.1.0.047)
*
The specific build and build date (for example, Build <builddate>)
*
The copyright date of the software

This option can be placed anywhere on the command line.

Alternate Options:

Linux and OS X: -V

-mcode
Tells the compiler which features it may
target, including which instruction sets it may generate.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
code
Indicates to the compiler a feature set that it may target, including which instruction sets it may generate. Many of the following descriptions refer to Intel(R) Streaming SIMD Extensions (Intel(R) SSE) and Supplemental Streaming SIMD Extensions (SSSE). Possible values are:
avx
May generate Intel(R) Advanced Vector Extensions (Intel(R) AVX), SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
sse4.2
May generate Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
sse4.1
May generate Intel(R) SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
ssse3
May generate SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions.
sse3
May generate Intel(R) SSE3, SSE2, and SSE instructions.
sse2
May generate Intel(R) SSE2 and SSE instructions. This value is only available on Linux systems.
sse
This option has been deprecated; it is now the same as specifying ia32.
ia32
Generates x86/x87 generic code that is compatible with IA-32 architecture. Disables any default extended instruction settings, and any previously set extended instruction settings. It also disables all feature-specific optimizations and instructions. This value is only available on Linux* systems using IA-32 architecture.
Default:
Linux* systems:
-msse2 OS X* systems using IA-32 architecture: -msse3 OS X* systems using Intel(R) 64 architecture: -mssse3 For more information on the default values, see Arguments above.
Description:

This option tells the compiler which features it may target, including which instruction sets it may generate.

Code generated with these options should execute on any compatible, non-Intel processor with support for the corresponding instruction set.

Options -x and -m are mutually exclusive. If both are specified, the compiler uses the last one specified and generates a warning.

Linux* systems: For compatibility with gcc, the compiler allows the following options but they have no effect. You will get a warning error, but the instructions associated with the name will not be generated. You should use the suggested replacement options.

gcc Compatibility Option (Linux* OS)
Suggested Replacement Option
-mfma
-march=core-avx2
-mbmi,
-mavx2, -mlzcnt -march=core-avx2
-mmovbe
-march=atom -minstruction=movbe
-mcrc32,
-maes, -mpclmul, -mpopcnt -march=corei7
-mvzeroupper
-march=corei7-avx
-mfsgsbase,
-mrdrnd, -mf16c -march=core-avx-i

Many of the above gcc options are not available on Intel(R) MIC Architecture.

Alternate Options:

Linux and OS X: None

-m32
-m64
Tells the compiler to generate code for a
specific architecture.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
OFF
The compiler[aq]s behavior depends on the host system.
Description:

These options tell the compiler to generate code for a specific architecture.

Option
Description
-m32 or
/Qm32 Tells the compiler to generate code for IA-32 architecture.
-m64 or
/Qm64 Tells the compiler to generate code for Intel(R) 64 architecture.

The -m32 and -m64 options are the same as OS X* options -arch i386 and -arch x86_64, respectively. These options are not related to the Intel(R) Fortran Compiler option arch.

On Linux* systems, these options are provided for compatibility with gcc.

Alternate Options:

None

-map-opts (L*X only)
Maps one or more compiler options to their equivalent on a different operating system.
Arguments:

None

Default:
OFF
No platform mappings are performed.
Description:

This option maps one or more compiler options to their equivalent on a different operating system. The result is output to stdout.

On Windows systems, the options you provide are presumed to be Windows options, so the options that are output to stdout will be Linux equivalents.

On Linux systems, the options you provide are presumed to be Linux options, so the options that are output to stdout will be Windows equivalents.

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.

This option is useful if you have both compilers and want to convert scripts or makefiles.

NOTE: Compiler options are mapped to their equivalent on the architecture you are using. For example, if you are using a processor with IA-32 architecture, you will only see equivalent options that are available on processors with IA-32 architecture.

Alternate Options:

None

-march=processor
Tells the compiler to generate code for
processors that support certain features.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
processor
Indicates to the compiler the code it may generate. Possible values are:
generic
Generates code for the compiler[aq]s default behavior.
core-avx2
Generates code for processors that support Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
core-avx-i
Generates code for processors that support the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
corei7-avx
Generates code for processors that support Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
corei7
Generates code for processors that support Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions. May also generate code for Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions.
atom
Generates code for processors that support MOVBE instructions, depending on the setting of option -minstruction (Linux* OS and OS X*) or /Qinstruction (Windows* OS). May also generate code for SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions.
core2
Generates code for the Intel(R) Core(TM) 2 processor family.
pentium-mmx
Generates for Intel(R) Pentium(R) with MMX technology.
pentiumpro
Generates for Intel(R) Pentium(R) Pro, Intel Pentium II, and Intel Pentium III processors.
pentium4m
Generates for Intel(R) Pentium(R) 4 processors with MMX technology.
pentium-m pentium4 pentium3 pentium
Generates code for Intel(R) Pentium(R) processors. Value pentium3 is only available on Linux* OS.
Default:
pentium4
If no architecture option is specified, value pentium4 is used by the compiler to generate code.
Description:

This option tells the compiler to generate code for processors that support certain features.

If you specify both the -ax and -march options, the compiler will not generate Intel-specific instructions.

Specifying -march=pentium4 sets -mtune=pentium4.

For compatibility, a number of historical processor values are also supported, but the generated code will not differ from the default.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:
-march=pentium3
Linux: -xSSE
OS X: None
-march=pentium4 -march=pentium-m
Linux: -xSSE2
OS X: None
-march=core2
Linux: -xSSSE3
OS X: None
-mcmodel=mem_model (L*X only)
Tells the compiler to use a specific memory model to generate code and store data.
Architecture Restrictions: Only available on Intel(R) 64 architecture
Arguments:
mem_model
Is the memory model to use. Possible values are:
small
Tells the compiler to restrict 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.
medium
Tells the compiler to restrict 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.
Default:
-mcmodel=small
On systems using Intel(R) 64 architecture, the compiler restricts code and data to the first 2GB of address space. Instruction Pointer (IP)-relative addressing can be used to access code and data.
Description:

This option tells the compiler to use a specific memory model to generate code and store data. It can affect code size and performance. 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 you specify option -mcmodel=medium or -mcmodel=large, it sets option -shared-intel. This ensures that the correct dynamic versions of the Intel run-time libraries are used.

If you specify option -static-intel while -mcmodel=medium or -mcmodel=large is set, an error will be displayed.

Alternate Options:

None

-mdynamic-no-pic (M*X only)
Generates code that is not position-independent but has position-independent external references.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
All references are generated as position independent.
Description:

This option generates code that is not position-independent but has position-independent external references.

The generated code is suitable for building executables, but it is not suitable for building shared libraries.

This option may reduce code size and produce more efficient code. It overrides the -fpic compiler option.

Alternate Options:

None

-minstruction=[no]movbe
Determines whether MOVBE instructions are
generated for certain Intel processors.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
–minstruction=nomovbe
The compiler does not generate MOVBE instructions for Intel(R) Atom(TM) processors.
Description:

This option determines whether MOVBE instructions are generated for Intel(R) Atom(TM) processors. To use this option, you must also specify [Q]xATOM_SSSE3 or [Q]xATOM_SSE4.2.

If -minstruction=movbe or /Qinstruction:movbe is specified, the following occurs:

*
MOVBE instructions are generated that are specific to the Intel(R) Atom(TM) processor.
*
Generated executables can only be run on Intel(R) Atom(TM) processors or processors that support Supplemental Streaming SIMD Extensions 3 (Intel(R) SSSE3) or Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) and MOVBE.

If -minstruction=nomovbe or /Qinstruction:nomovbe is specified, the following occurs:

*
The compiler optimizes code for the Intel(R) Atom(TM) processor, but it does not generate MOVBE instructions.
*
Generated executables can be run on non-Intel(R) Atom(TM) processors that support Intel(R) SSE3 or Intel(R) SSE4.2.
Alternate Options:

None

-mkl[=lib]
Tells the compiler to link to certain libraries in the Intel(R) Math Kernel Library (Intel(R) MKL). On Windows systems, you must specify this option at compile time.
Arguments:
lib
Indicates which Intel(R) MKL library files should be linked. Possible values are:
parallel
Tells the compiler to link using the threaded libraries in the Intel(R) MKL. This is the default if the option is specified with no lib.
sequential
Tells the compiler to link using the sequential libraries in the Intel(R) MKL.
cluster
Tells the compiler to link using the cluster-specific libraries and the sequential libraries in the Intel(R) MKL. Cluster-specific libraries are not available for OS X*.
Default:
OFF
The compiler does not link to the Intel(R) MKL.
Description:

This option tells the compiler to link to certain libraries in the Intel(R) Math Kernel Library (Intel(R) MKL).

On Linux* OS and OS X*, dynamic linking is the default when you specify -mkl. To link with Intel(R) MKL statically, you must specify:

-mkl -static-intel

On Windows* OS, static linking is the default when you specify /Qmkl. To link with Intel(R) MKL dynamically, you must specify:

/Qmkl /libs:dll or /Qmkl /MD

For more information about using MKL libraries, see the article in Intel(R) Developer Zone titled Intel(R) Math Kernel Library Link Line Advisor.

NOTE: On Windows* OS, this option adds directives to the compiled code, which the linker then reads without further input from the driver. On Linux* OS and OS X, the driver must add the library names explicitly to the link command.

NOTE: If you specify option [Q]mkl or [Q]mkl=parallel, and you also specify option [Q]tbb, the compiler links to the standard threaded version of the Intel(R) MKL. However, if you specify [Q]mkl or [Q]mkl=parallel, and you also specify option [Q]tbb and option [q or Q]openmp, the compiler links to the OpenMP* threaded version of the Intel(R) MKL.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-mmic (L*X only)
Builds an application that runs natively
on Intel(R) MIC Architecture. This option only applies to Intel(R) MIC Architecture.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
OFF
The compiler builds a heterogeneous application. You must specify this option to build an application that runs natively on Intel(R) MIC Architecture.
Description:

This option enables the cross compiler to build an application that runs natively on Intel(R) MIC Architecture. It is only available on the command line.

When you use this option, the compiler defines the macro __MIC__.

NOTE: When you specify Windows* option /Qmic, you must specify any other options on the command line in the Linux* form. This is because all other options are passed directly to the native Intel(R) MIC Architecture compiler, which is a Windows*-hosted Linux* compiler.

Alternate Options:

None

-module path
Specifies the directory where module files should be placed when created and where they should be searched for.
Arguments:
path
Is the directory for module files.
Default:
OFF
The compiler places module files in the current directory.
Description:

This option specifies the directory (path) where module (.mod) files should be placed when created and where they should be searched for (USE statement).

Alternate Options:

None

-mp1
Improves floating-point precision and consistency.
Arguments:

None

Default:
OFF
The compiler provides good accuracy and run-time performance at the expense of less consistent floating-point results.
Description:

This option improves floating-point consistency. It ensures the out-of-range check of operands of transcendental functions and improves the accuracy of floating-point compares.

This option prevents the compiler from performing optimizations that change NaN comparison semantics and causes all values to be truncated to declared precision before they are used in comparisons. It also causes the compiler to use library routines that give better precision results compared to the X87 transcendental instructions.

This option disables fewer optimizations and has less impact on performance than option fltconsistency.

This option disables fewer optimizations and has less impact on performance than option fltconsistency,-fp-model precise (Linux* OS and OS X*), or option /fp:precise (Windows* OS).

Alternate Options:

None

-mtune=processor
Performs optimizations for specific
processors.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
processor
Is the processor for which the compiler should perform optimizations. Possible values are:
generic
Optimizes code for the compiler[aq]s default behavior.
core-avx2
Optimizes code for processors that support Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
core-avx-i
Optimizes code for processors that support the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
corei7-avx
Optimizes code for processors that support Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions.
corei7
Optimizes code for processors that support Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions. May also generate code for Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions.
atom
Optimizes code for processors that support MOVBE instructions, depending on the setting of option -minstruction (Linux* OS and OS X*) or /Qinstruction (Windows* OS). May also generate code for SSSE3 instructions and Intel(R) SSE3, SSE2, and SSE instructions.
core2
Optimizes for the Intel(R) Core(TM) 2 processor family, including support for MMX(TM), Intel(R) SSE, SSE2, SSE3 and SSSE3 instruction sets.
pentium-mmx
Optimizes for Intel(R) Pentium(R) with MMX technology.
pentiumpro
Optimizes for Intel(R) Pentium(R) Pro, Intel Pentium II, and Intel Pentium III processors.
pentium4m
Optimizes for Intel(R) Pentium(R) 4 processors with MMX technology.
pentium-m pentium4 pentium3 pentium
Optimizes code for Intel(R) Pentium(R) processors. Value pentium3 is only available on Linux* OS.
Default:
generic
Code is generated for the compiler[aq]s default behavior.
Description:

This option performs optimizations for specific processors.

The resulting executable is backwards compatible and generated code is optimized for specific processors. For example, code generated with -mtune=pentium4 will run correctly on Core2 processors, but it might not run as fast as if it had been generated using -mtune=core2.

The following table shows on which architecture you can use each value.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:
-mtune
Linux: -mcpu (this is a deprecated option)
OS X: None
-multiple-processes[=n]
Creates multiple processes that can be used to compile large numbers of source files at the same time.
Arguments:
n
Is the maximum number of processes that the compiler should create.
Default:
OFF
A single process is used to compile source files.
Description:

This option creates multiple processes that can be used to compile large numbers of source files at the same time. It can improve performance by reducing the time it takes to compile source files on the command line.

This option causes the compiler to create one or more copies of itself, each in a separate process. These copies simultaneously compile the source files.

If n is not specified for this option, the default value is as follows:

*
On Windows* OS, the value is based on the setting of the NUMBER_OF_PROCESSORS environment variable.
*
On Linux* OS and OS X*, the value is 2.

This option applies to compilations, but not to linking or link-time code generation.

Alternate Options:

None

-names keyword
Specifies how source code identifiers and external names are interpreted.
Arguments:
keyword
Specifies how to interpret the identifiers and external names in source code. Possible values are:
lowercase
Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase.
uppercase
Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase.
as_is
Causes the compiler to distinguish case differences in identifiers and to preserve the case of external names.
Default:
lowercase
This is the default on Linux* and OS X* systems. The compiler ignores case differences in identifiers and converts external names to lowercase.
uppercase
This is the default on Windows* systems. The compiler ignores case differences in identifiers and converts external names to uppercase.
Description:

This option specifies how source code identifiers and external names are interpreted. It can be useful in mixed-language programming.

This naming convention applies whether names are being defined or referenced.

You can use the ALIAS directive to specify an alternate external name to be used when referring to external subprograms.

CAUTION: On Windows systems, if you specify option /iface:cref, it overrides the default for external names and causes them to be lowercase. It is as if you specified "!dir$ attributes c, reference" for the external name.

If you specify option /iface:cref and want external names to be uppercase, you must explicitly specify option /names:uppercase.

Alternate Options:

None

-no-bss-init
Tells the compiler to place in the DATA section any uninitialized variables and explicitly zero-initialized variables.
Arguments:

None

Default:
OFF
Uninitialized variables and explicitly zero-initialized variables are placed in the BSS section.
Description:

This option tells the compiler to place in the DATA section any uninitialized variables and explicitly zero-initialized variables.

Alternate Options:

None

-nodefaultlibs
Prevents the compiler from using standard libraries when linking.
Arguments:

None

Default:
OFF
The standard libraries are linked.
Description:

This option prevents the compiler from using standard libraries when linking.

Alternate Options:

None

-nofor-main
Specifies that the main program is not written in Fortran.
Arguments:

None

Default:
OFF
The compiler assumes the main program is written in Fortran.
Description:

This option specifies that the main program is not written in Fortran. It is a link-time option that prevents the compiler from linking for_main.o into applications.

For example, if the main program is written in C and calls a Fortran subprogram, specify -nofor-main when compiling the program with the ifort command.

If you omit this option, the main program must be a Fortran program.

Alternate Options:

None

-nolib-inline
Disables inline expansion of standard library or intrinsic functions.
Arguments:

None

Default:
OFF
The compiler inlines many standard library and intrinsic functions.
Description:

This option disables inline expansion of standard library or intrinsic functions. It prevents the unexpected results that can arise from inline expansion of these functions.

Alternate Options:

None

-nostartfiles
Prevents the compiler from using standard startup files when linking.
Arguments:

None

Default:
OFF
The compiler uses standard startup files when linking.
Description:

This option prevents the compiler from using standard startup files when linking.

Alternate Options:

None

-nostdlib
Prevents the compiler from using standard libraries and startup files when linking.
Arguments:

None

Default:
OFF
The compiler uses standard startup files and standard libraries when linking.
Description:

This option prevents the compiler from using standard libraries and startup files when linking.

This option is not related to option -stdlib.

Alternate Options:

None

-o filename
Specifies the name for an output file.
Arguments:
filename
Is the name for the output file. The space before filename is optional.
Default:
OFF
The compiler uses the default file name for an output file.
Description:

This option specifies the name 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, it specifies the name of the executable file.

Alternate Options:

Linux and OS X: None

Windows: /exe

-O[n]
Specifies the code optimization for applications.
Arguments:
n
Is the optimization level. Possible values are 1, 2, or 3. On Linux* and OS X* systems, you can also specify 0.
Default:
O2
Optimizes for code speed. This default may change depending on which other compiler options are specified. For details, see below.
Description:

This option specifies the code optimization for applications.

Option
Description
O (Linux* OS and OS X*)
This is the same as specifying O2.
O0 (Linux OS and OS X)
Disables all optimizations.
This option may set other options. This is determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.
This option causes certain warn options to be ignored. This is the default if you specify option -debug (with no keyword).
O1
Enables optimizations for speed and disables some optimizations that increase code size and affect speed. To limit code size, this option:
*
Enables global optimization; this includes data-flow analysis, code motion, strength reduction and test replacement, split-lifetime analysis, and instruction scheduling.
This option may set other options. This is determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.
The O1 option may improve performance for applications with very large code size, many branches, and execution time not dominated by code within loops.
O2
Enables optimizations for speed. This is the generally recommended optimization level. Vectorization is enabled at O2 and higher levels.
On systems using IA-32 architecture: Some basic loop optimizations such as Distribution, Predicate Opt, Interchange, multi-versioning, and scalar replacements are performed.
This option also enables:
*
Inlining of intrinsics
*
Intra-file interprocedural optimization, which includes:
*
inlining
*
constant propagation
*
forward substitution
*
routine attribute propagation
*
variable address-taken analysis
*
dead static function elimination
*
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
*
dead store elimination
This option may set other options, especially options that optimize for code speed. This is determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.
On Windows* systems, this option is the same as the Ox option.
On Linux* and OS X* systems, if -g is specified, O2 is turned off and O0 is the default unless O2 (or O1
or O3) is explicitly specified in the command line together with -g.
On Linux systems, the -debug inline-debug-info option will be enabled by default if you compile with optimizations (option -O2 or higher) and debugging is enabled (option -g).
Many routines in the shared libraries are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.
O3
Performs O2 optimizations and enables more aggressive loop transformations such as Fusion, Block-Unroll-and-Jam, and collapsing IF statements.
This option may set other options. This is determined by the compiler, depending on which operating system and architecture you are using. The options that are set may change from release to release.
When O3 is used with options -ax or -x (Linux OS) or with options /Qax or /Qx (Windows OS), the compiler performs more aggressive data dependency analysis than for O2, which may result in longer compilation times.
The O3 optimizations may not cause higher performance unless loop and memory access transformations take place. The optimizations may slow down code in some cases compared to O2 optimizations.
The O3 option is recommended for applications that have loops that heavily use floating-point calculations and process large data sets.
Many routines in the shared libraries are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

The last O option specified on the command line takes precedence over any others.

-Ofast
Sets certain aggressive options to improve the speed of your application.
Arguments:

None

Default:
OFF
The aggressive optimizations that improve speed are not enabled.
Description:

This option improves the speed of your application.

It sets compiler options -O3, -no-prec-div, and -fp-model fast=2.

On Linux* systems, this option is provided for compatibility with gcc.

Alternate Options:

None

-Os
Enables optimizations that do not increase code size; it produces smaller code size than O2.
Arguments:

None

Default:
OFF
Optimizations are made for code speed. However, if O1 is specified, Os is the default.
Description:

This option enables optimizations that do not increase code size; it produces smaller code size than O2. It disables some optimizations that increase code size for a small speed benefit.

This option tells the compiler to favor transformations that reduce code size over transformations that produce maximum performance.

Alternate Options:

None

-p
Compiles and links for function profiling
with gprof(1).
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
OFF
Files are compiled and linked without profiling.
Description:

This option compiles and links for function profiling with gprof(1).

When you specify this option, inlining is disabled. However, you can override this by specifying directive FORCEINLINE, or a compiler option such as [Q]inline-forceinline.

Alternate Options:

Linux and OS X: -pg,-qp (this is a deprecated option)

-pad
-nopad
Enables the changing of the variable and array memory layout.
Arguments:

None

Default:
-nopad
Variable and array memory layout is performed by default methods.
Description:

This option enables the changing of the variable and array memory layout.

This option is effectively not different from the align option when applied to structures and derived types. However, the scope of pad is greater because it applies also to common blocks, derived types, sequence types, and structures.

Alternate Options:

None

-pad-source
-nopad-source
Specifies padding for fixed-form source records.
Arguments:

None

Default:
-nopad-source
Fixed-form source records are not padded.
Description:

This option specifies padding for fixed-form source records. It tells the compiler that fixed-form source lines shorter than the statement field width are to be padded with spaces to the end of the statement field. This affects the interpretation of character and Hollerith literals that are continued across source records.

The default value setting causes a warning message to be displayed if a character or Hollerith literal that ends before the statement field ends is continued onto the next source record. To suppress this warning message, specify setting nousage for option warn.

Specifying [Q]pad-source can prevent warning messages associated with setting usage for option warn.

Alternate Options:

None

-parallel
Tells the auto-parallelizer to generate multithreaded code for loops that can be safely executed in parallel.
Arguments:

None

Default:
OFF
Multithreaded code is not generated for loops that can be safely executed in parallel.
Description:

This option 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 option O2 or O3.

This option sets option [q or Q]opt-matmul if option O3 is also specified.

NOTE: On OS X* systems, when you enable automatic parallelization, you must also set the DYLD_LIBRARY_PATH environment variable within Xcode* or an error will be displayed.

NOTE: Using this option enables parallelization for both Intel(R) microprocessors and non-Intel microprocessors. The resulting executable may get additional performance gain on Intel microprocessors than on non-Intel microprocessors. The parallelization can also be affected by certain options, such as /arch or /Qx (Windows OS) or -m or -x (Linux OS and OS X).

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-parallel-source-info[=n]
-no-parallel-source-info
Enables or disables source location emission when OpenMP* or auto-parallelism code is generated.
Arguments:
n
Is the level of source location emission. Possible values are:
0
Disables the emission of source location information when OpenMP* code or auto-parallelism code is generated. This is the same as specifying -no-parallel-source-info (Linux* OS and OS X*) or /Qparallel-source-info- (Windows* OS).
1
Tells the compiler to emit routine name and line information. This is the same as specifying [Q]parallel-source-info with no n.
2
Tells the compiler to emit path, file, routine name, and line information.
Default:
-parallel-source-info=1
When OpenMP* code or auto-parallelism code is generated, the routine name and line information is emitted.
Description:

This option enables or disables source location emission when OpenMP code or auto-parallelism code is generated. It also lets you set the level of emission.

Alternate Options:

None

-par-affinity=[modifier,...]type[,permute][,offset] (L*X only)
Specifies thread affinity.
Arguments:
modifier
Is one of the following values: granularity={fine|thread|core}, [no]respect, [no]verbose, [no]warnings, proclist=proc_list. The default is granularity=core, respect, and noverbose.
type
Indicates the thread affinity. This argument is required and must be one of the following values: compact, disabled, explicit, none, scatter, logical, physical. The default is none. Values logical and physical are deprecated. Use compact and scatter, respectively, with no permute value.
permute
Is a positive integer. You cannot use this argument with type setting explicit, none, or disabled. The default is 0.
offset
Is a positive integer. You cannot use this argument with type setting explicit, none, or disabled. The default is 0.
Default:
OFF
The thread affinity is determined by the run-time environment.
Description:

This option specifies thread affinity, which binds threads to physical processing units. It has the same effect as environment variable KMP_AFFINITY.

This option overrides the environment variable when both are specified.

This option only has an effect if the following is true:

*
You have specified option [Q]parallel or option [q or Q]openmp (or both).
*
You are compiling the main program.

NOTE: This option may behave differently on Intel(R) microprocessors than on non-Intel microprocessors.

Alternate Options:

None

-par-num-threads=n
Specifies the number of threads to use in a parallel region.
Arguments:
n
Is the number of threads to use. It must be a positive integer.
Default:
OFF
The number of threads to use is determined by the run-time environment.
Description:

This option specifies the number of threads to use in a parallel region. It has the same effect as environment variable OMP_NUM_THREADS.

This option overrides the environment variable when both are specified.

This option only has an effect if the following is true:

*
You have specified option [Q]parallel or option [q or Q]openmp (or both).
*
You are compiling the main program.
Alternate Options:

None

-par-runtime-control[n]
-no-par-runtime-control
Generates code to perform run-time checks for loops that have symbolic loop bounds.
Arguments:
n
Is a a value denoting what kind of runtime checking to perform. Possible values are:
0
Performs no runtime check based on auto-parallelization. This is the same as specifying -no-par-runtime-control (Linux* OS and OS X*) or /Qpar-runtime-control- (Windows* OS).
1
Generates runtime check code under conservative mode. This is the default if you do not specify n.
2
Generates runtime check code under heuristic mode.
3
Generates runtime check code under aggressive mode.
Default:
-no-par-runtime-control
The compiler uses default heuristics when checking loops.
Description:

This option generates code to perform run-time checks for loops that have symbolic loop bounds.

If the granularity of a loop is greater than the parallelization threshold, the loop will be executed in parallel.

If you do not specify this option, the compiler may not parallelize loops with symbolic loop bounds if the compile-time granularity estimation of a loop can not ensure it is beneficial to parallelize the loop.

NOTE: This option may behave differently on Intel(R) microprocessors than on non-Intel microprocessors.

Alternate Options:

None

-par-schedule-keyword[=n]
Lets you specify a scheduling algorithm for loop iterations.
Arguments:
keyword
Specifies the scheduling algorithm or tuning method. Possible values are:
auto
Lets the compiler or run-time system determine the scheduling algorithm.
static
Divides iterations into contiguous pieces.
static-balanced
Divides iterations into even-sized chunks.
static-steal
Divides iterations into even-sized chunks, but allows threads to steal parts of chunks from neighboring threads.
dynamic
Gets a set of iterations dynamically.
guided
Specifies a minimum number of iterations.
guided-analytical
Divides iterations by using exponential distribution or dynamic distribution.
runtime
Defers the scheduling decision until run time.
n
Is the size of the chunk or the number of iterations for each chunk. This setting can only be specified for static, dynamic, and guided. For more information, see the descriptions of each keyword below.
Default:
static-balanced
Iterations are divided into even-sized chunks and the chunks are assigned to the threads in the team in a round-robin fashion in the order of the thread number.
Description:

This option lets you specify a scheduling algorithm for loop iterations. It specifies how iterations are to be divided among the threads of the team.

This option is only useful when specified with option [Q]parallel.

This option affects performance tuning and can provide better performance during auto-parallelization. It does nothing if it is used with option [q or Q]openmp.

Option
Description
[Q]par-schedule-auto
Lets the compiler or run-time system determine the scheduling algorithm. Any possible mapping may occur for iterations to threads in the team.
[Q]par-schedule-static
Divides iterations into contiguous pieces (chunks) of size n. The chunks are assigned to threads in the team in a round-robin fashion in the order of the thread number. Note that the last chunk to be assigned may have a smaller number of iterations.
If no n is specified, the iteration space is divided into chunks that are approximately
equal in size, and each thread is assigned at most one chunk.
[Q]par-schedule-static-balanced
Divides iterations into even-sized chunks. The chunks are assigned to the threads in the team in a round-robin fashion in the order of the thread number.
[Q]par-schedule-static-steal
Divides iterations into even-sized chunks, but when a thread completes its chunk, it can steal parts of chunks assigned to neighboring threads.
Each thread keeps track
of L and U, which represent the lower and upper bounds of its chunks respectively. Iterations are executed starting from the lower bound, and simultaneously, L is updated to represent the new lower bound.
[Q]par-schedule-dynamic
Can be used to get a set of iterations dynamically. Assigns iterations to threads in chunks as the threads request them. The thread executes the chunk of iterations, then requests another chunk, until no chunks remain to be assigned.
As each thread finishes a piece of the iteration space, it dynamically gets the next
set of iterations. Each chunk contains n iterations, except for the last chunk to be assigned, which may have fewer iterations. If no n is specified, the default is 1.
[Q]par-schedule-guided
Can be used to specify a minimum number of iterations. Assigns iterations to threads in chunks as the threads request them. The thread executes the chunk of iterations, then requests another chunk, until no chunks remain to be assigned.
For a chunk of size 1, the size of each chunk is proportional to the number of unassigned
iterations divided by the number of threads, decreasing to 1.
For an n with value
k (greater than 1), the size of each chunk is determined in the same way with the restriction that the chunks do not contain fewer than k iterations (except for the last chunk to be assigned, which may have fewer than k iterations). If no n is specified, the default is 1.
[Q]par-schedule-guided-analytical
Divides iterations by using exponential distribution or dynamic distribution. The method depends on run-time implementation. Loop bounds are calculated with faster synchronization and chunks are dynamically dispatched at run time by threads in the team.
[Q]par-schedule-runtime
Defers the scheduling decision until run time. The scheduling algorithm and chunk size are then taken from the setting of environment variable OMP_SCHEDULE.

NOTE: This option may behave differently on Intel(R) microprocessors than on non-Intel microprocessors.

Alternate Options:

None

-par-threshold[n]
Sets a threshold for the auto-parallelization of loops.
Arguments:
n
Is an integer whose value is the threshold for the auto-parallelization of loops. Possible values are 0 through 100.
If n is 0, loops get auto-parallelized always, regardless of computation work volume.
If n is 100, loops get auto-parallelized when performance gains are predicted based on the compiler analysis data. Loops get auto-parallelized only if profitable parallel execution is almost certain.
The intermediate 1 to 99 values represent the percentage probability for profitable speed-up. For example, n=50 directs the compiler to parallelize only if there is a 50% probability of the code speeding up if executed in parallel.
Default:
-par-threshold100
Loops get auto-parallelized only if profitable parallel execution is almost certain. This is also the default if you do not specify n.
Description:

This option sets a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. To use this option, you must also specify option [Q]parallel.

This option is useful 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.

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.

NOTE: This option may behave differently on Intel(R) microprocessors than on non-Intel microprocessors.

Alternate Options:

None

-pcn
Enables control of floating-point significand precision.
Arguments:
n
Is the floating-point significand precision. Possible values are:
32
Rounds the significand to 24 bits (single precision).
64
Rounds the significand to 53 bits (double precision).
80
Rounds the significand to 64 bits (extended precision).
Default:
-pc80
On Linux* and OS X* systems, the floating-point significand is rounded to 64 bits.
Description:

This option 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 this option.

Note that a change of the default precision control or rounding mode, for example, by using the [Q]pc32 option or by user intervention, may affect the results returned by some of the mathematical functions.

Alternate Options:

None

-pie
-no-pie
Determines whether the compiler generates position-independent code that will be linked into an executable.
Arguments:

None

Default:
varies
On Linux* OS and on OS X* versions less than 10.7, the default is -no-pie. On OS X* 10.7 or greater, the default is -pie.
Description:

This option determines whether the compiler generates position-independent code that will be linked into an executable. To enable generation of position-independent code that will be linked into an executable, specify -pie.

To disable generation of position-independent code that will be linked into an executable, specify -no-pie.

Alternate Options:

None

-prec-div
-no-prec-div
Improves precision of floating-point divides.
Arguments:

None

Default:
-prec-div
The compiler uses this method for floating-point divides.
Description:

This option improves precision of floating-point divides. It has a slight impact on speed.

With some optimizations, such as -msse2 (Linux* OS) or /arch:SSE2 (Windows* OS), 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.

However, sometimes the value produced by this transformation is not as accurate as full IEEE division. When it is important to have fully precise IEEE division, use this option to disable the floating-point division-to-multiplication optimization. The result is more accurate, with some loss of performance.

If you specify -no-prec-div (Linux* OS and OS X*) or /Qprec-div- (Windows* OS), it enables optimizations that give slightly less precise results than full IEEE division.

Alternate Options:

None

-prec-sqrt
-no-prec-sqrt
Improves precision of square root implementations.
Arguments:

None

Default:
-no-prec-sqrt
The compiler uses a faster but less precise implementation of square root.
However, the default is -prec-sqrt if any of the following options are specified: -O0, -fltconsistency, or -mp1 on Linux* and OS X* systems.
Description:

This option improves precision of square root implementations. It has a slight impact on speed.

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.

Alternate Options:

None

-preprocess-only
Causes the Fortran preprocessor to send output to a file.
Arguments:

None

Default:
OFF
Preprocessed source files are output to the compiler.
Description:

This option causes the Fortran preprocessor to send output to a file.

The source file is preprocessed by the Fortran preprocessor, and the result for each source file is output to a corresponding .i or .i90 file.

Note that the source file is not compiled.

Alternate Options:

Linux and OS X: -P

-print-multi-lib
Prints information about where system libraries should be found.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
No information is printed unless the option is specified.
Description:

This option prints information about where system libraries should be found, but no compilation occurs. On Linux* systems, it is provided for compatibility with gcc.

Alternate Options:

None

-print-sysroot (L*X only)
Prints the target sysroot directory that is used during compilation.
Architectures: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
Nothing is printed.
Description:

This option prints the target sysroot directory that is used during compilation.

This is the target sysroot directory that is specified in an environment file or in option --sysroot. This option is only effective if a target sysroot has been specified.

Alternate Options:

None

-prof-data-order (L*X only)
-no-prof-data-order (L*X only)
Enables or disables data ordering if
profiling information is enabled.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
-no-prof-data-order
Data ordering is disabled.
Description:

This option enables or disables data ordering if profiling information is enabled. It controls the use of profiling information to order static program data items.

For this option to be effective, you must do the following:

*
For instrumentation compilation, you must specify option [Q]prof-gen setting globdata.
*
For feedback compilation, you must specify the [Q]prof-use option. You must not use multi-file optimization by specifying options such as [Q]ipo or [Q]ipo-c.
Alternate Options:

None

-prof-dir dir
Specifies a directory for profiling information output files.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
dir
Is the name of the directory. You can specify a relative pathname or an absolute pathname.
Default:
OFF
Profiling output files are placed in the directory where the program is compiled.
Description:

This option specifies a directory for profiling information output files (*.dyn and *.dpi). The specified directory must already exist.

You should specify this option using the same directory name for both instrumentation and feedback compilations. If you move the .dyn files, you need to specify the new path.

Option /Qprof-dir is equivalent to option /Qcov-dir. If you specify both options, the last option specified on the command line takes precedence.

Alternate Options:

None

-prof-file filename
Specifies an alternate file name for the profiling summary files.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
filename
Is the name of the profiling summary file.
Default:
OFF
The profiling summary files have the file name pgopti.*
Description:

This option specifies an alternate file name for the profiling summary files. The filename is used as the base name for files created by different profiling passes.

If you add this option to profmerge, the .dpi file will be named filename.dpi instead of pgopti.dpi.

If you specify this option with option [Q]prof-use, the .dpi file will be named filename.dpi instead of pgopti.dpi.

Option /Qprof-file is equivalent to option /Qcov-file. If you specify both options, the last option specified on the command line takes precedence.

NOTE: When you use option [Q]prof-file, you can only specify a file name. If you want to specify a path (relative or absolute) for filename, you must also use option [Q]prof-dir.

Alternate Options:

None

-prof-func-groups (L*X only)
-no-prof-func-groups (L*X only)
Enables or disables function grouping if
profiling information is enabled.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
-no-prof-func-groups
Function grouping is disabled.
Description:

This option enables or disables function grouping if profiling information is enabled.

A "function grouping" is a profiling optimization in which entire routines are placed either in the cold code section or the hot code section.

If profiling information is enabled by option -prof-use, option -prof-func-groups is set and function grouping is enabled. However, if you explicitly enable -prof-func-order, function ordering is performed instead of function grouping.

If you want to disable function grouping when profiling information is enabled, specify -no-prof-func-groups.

To set the hotness threshold for function grouping, use option -prof-hotness-threshold.

-prof-func-order (L*X only)
-no-prof-func-order (L*X only)
Enables or disables function ordering if
profiling information is enabled.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
-no-prof-func-order
Function ordering is disabled.
Description:

This option enables or disables function ordering if profiling information is enabled.

For this option to be effective, you must do the following:

*
For instrumentation compilation, you must specify option [Q]prof-gen setting srcpos.
*
For feedback compilation, you must specify [Q]prof-use. You must not use multi-file optimization by specifying options such as [Q]ipo or [Q]ipo-c.

If you enable profiling information by specifying option [Q]prof-use, option [Q]prof-func-groups is set and function grouping is enabled. However, if you explicitly enable the [Q]prof-func-order option, function ordering is performed instead of function grouping.

On Linux* systems, this option is only available for Linux linker 2.15.94.0.1, or later.

To set the hotness threshold for function grouping and function ordering, use option [Q]prof-hotness-threshold.

Alternate Options:

None

-prof-gen[=keyword[, keyword],...]
-no-prof-gen
Produces an instrumented object file that
can be used in profile guided optimization.
Arguments:
keyword
Specifies details for the instrumented file. Possible values are:
default
Produces an instrumented object file. This is the same as specifying the [Q]prof-gen option with no keyword.
srcpos
Produces an instrumented object file that includes extra source position information.
globdata
Produces an instrumented object file that includes information for global data layout.
[no]threadsafe
Produces an instrumented object file that includes the collection of PGO data on applications that use a high level of parallelism. If [Q]prof-gen is specified with no keyword, the default is nothreadsafe.
On Intel(R) 64 architecture targeting the Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner), the only valid mode is keyword threadsafe.
Default:
-no-prof-gen
Profile generation is disabled.
Description:

This option produces an instrumented object file that can be used in profile guided optimization. It gets the execution count of each basic block.

You can specify more than one setting for [Q]prof-gen. For example, you can specify the following:

–prof-gen=scrpos -prof-gen=threadsafe (Linux* OS and OS X*) -prof-gen=scrpos, threadsafe (this is equivalent to the above)

/Qprof-gen:scrpos /Qprof-gen:threadsafe (Windows* OS) /Qprof-gen:scrpos, threadsafe (this is equivalent to the above)

If you specify keyword srcpos or globdata, a static profile information file (.spi) is created. These settings may increase the time needed to do a parallel build using -prof-gen, because of contention writing the .spi file.

These options are used in phase 1 of the Profile Guided Optimizer (PGO) to instruct the compiler to produce instrumented code in your object files in preparation for instrumented execution.

When the [Q]prof-gen option is used to produce an instrumented binary file for profile generation, some optimizations are disabled. Those optimizations are not disabled for any subsequent profile-guided compilation with option [Q]prof-use that makes use of the generated profiles.

Alternate Options:

None

-prof-hotness-threshold=n (L*X only)
Lets you set the hotness threshold for
function grouping and function ordering.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
n
Is the hotness threshold. n is a percentage having a value between 0 and 100 inclusive. If you specify 0, there will be no hotness threshold setting in effect for function grouping and function ordering.
Default:
OFF
The compiler[aq]s default hotness threshold setting of 10 percent is in effect for function grouping and function ordering.
Description:

This option lets you set the hotness threshold for function grouping and function ordering.

The "hotness threshold" is the percentage of functions in the application that should be placed in the application[aq]s hot region. The hot region is the most frequently executed part of the application. By grouping these functions together into one hot region, they have a greater probability of remaining resident in the instruction cache. This can enhance the application[aq]s performance.

For this option to take effect, you must specify option [Q]prof-use and one of the following:

*
On Linux systems: -prof-func-groups or -prof-func-order
*
On Windows systems: /Qprof-func-order
Alternate Options:

None

-prof-src-dir
-no-prof-src-dir
Determines whether directory information
of the source file under compilation is considered when looking up profile data records.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
prof-src-dir
Directory information is used when looking up profile data records in the .dpi file.
Description:

This option determines whether directory information of the source file under compilation is considered when looking up profile data records in the .dpi file. To use this option, you must also specify the [Q]prof-use option.

If the option is enabled, directory information is considered when looking up the profile data records within the .dpi file. You can specify directory information by using one of the following options:

*
Linux and OS X: -prof-src-root or -prof-src-root-cwd
*
Windows: /Qprof-src-root or /Qprof-src-root-cwd

If the option is disabled, directory information is ignored and only the name of the file is used to find the profile data record.

Note that option [Q]prof-src-dir controls how the names of the user[aq]s source files get represented within the .dyn or [Q]prof-dir specifies the location of the .dyn or the .dpi files.

Alternate Options:

None

-prof-src-root=dir
Lets you use relative directory paths when looking up profile data and specifies a directory as the base.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
dir
Is the base for the relative paths.
Default:
OFF
The setting of relevant options determines the path used when looking up profile data records.
Description:

This option lets you use relative directory paths when looking up profile data in .dpi files. It lets you specify a directory as the base. The paths are relative to a base directory specified during the [Q]prof-gen compilation phase.

This option is available during the following phases of compilation:

*
Linux OS and OS X: -prof-gen and -prof-use phases
*
Windows OS: /Qprof-gen and /Qprof-use phases

When this option is specified during the [Q]prof-gen phase, it stores information into the .dyn or .dpi file. Then, when .dyn files are merged together or the .dpi file is loaded, only the directory information below the root directory is used for forming the lookup key.

When this option is specified during the [Q]prof-use phase, it specifies a root directory that replaces the root directory specified at the [Q]prof-gen phase for forming the lookup keys.

To be effective, this option or option [Q]prof-src-root-cwd must be specified during the [Q]prof-gen phase. In addition, if one of these options is not specified, absolute paths are used in the .dpi file.

Alternate Options:

None

-prof-src-root-cwd
Lets you use relative directory paths when looking up profile data and specifies the current working directory as the base.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
The setting of relevant options determines the path used when looking up profile data records.
Description:

This option lets you use relative directory paths when looking up profile data in .dpi files. It specifies the current working directory as the base. To use this option, you must also specify option [Q]prof-use.

This option is available during the following phases of compilation:

*
Linux OS and OS X: -prof-gen and -prof-use phases
*
Windows OS: /Qprof-gen and /Qprof-use phases

When this option is specified during the [Q]prof-gen phase, it stores information into the .dyn or .dpi file. Then, when .dyn files are merged together or the .dpi file is loaded, only the directory information below the root directory is used for forming the lookup key.

When this option is specified during the [Q]prof-use phase, it specifies a root directory that replaces the root directory specified at the [Q]prof-gen phase for forming the lookup keys.

To be effective, this option or option [Q]prof-src-root must be specified during the [Q]prof-gen phase. In addition, if one of these options is not specified, absolute paths are used in the .dpi file.

Alternate Options:

None

-prof-use[=keyword]
-no-prof-use
Enables the use of profiling information
during optimization.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
keyword
Specifies additional instructions. Possible values are:
weighted
Tells the profmerge utility to apply a weighting to the .dyn file values when creating the .dpi file to normalize the data counts when the training runs have differentexecution durations. This argument only has an effect when the compiler invokes the profmerge utility to create the .dpi file. This argument does not have an effect if the .dpi file was previously created without weighting.
[no]merge
Enables or disables automatic invocation of the profmerge utility. The default is merge. Note that you cannot specify both weighted and nomerge. If you try to specify both values, a warning will be displayed and nomerge takes precedence.
default
Enables the use of profiling information during optimization. The profmerge utility is invoked by default. This value is the same as specifying [Q]prof-use with no argument.
Default:
-no-prof-use
Profiling information is not used during optimization.
Description:

This option enables the use of profiling information (including function splitting and function grouping) during optimization. It enables option /Qfnsplit (Windows* OS).

This option instructs the compiler to produce a profile-optimized executable and it merges available profiling output files into a pgopti.dpi file.

Note that there is no way to turn off function grouping if you enable it using this option.

To set the hotness threshold for function grouping and function ordering, use option [Q]prof-hotness-threshold.

Alternate Options:

None

-prof-value-profiling[=keyword]
Controls which values are value profiled.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
keyword
Controls which type of value profiling is performed. Possible values are:
none
Prevents all types of value profiling.
nodivide
Prevents value profiling of non-compile time constants used in division or remainder operations.
noindcall
Prevents value profiling of function addresses at indirect call sites.
all
Enables all types of value profiling.

You can specify more than one keyword, but they must be separated by commas.

Default:
all
All value profile types are enabled and value profiling is performed.
Description:

This option controls which features are value profiled.

If this option is specified with option [Q]prof-gen, it turns off instrumentation of operations of the specified type. This also prevents feedback of values for the operations.

If this option is specified with option [Q]prof-use, it turns off feedback of values collected of the specified type.

If you specify level 2 or higher for option[q or Q]opt-report, the value profiling specialization information will be reported within the PGO optimization report.

Alternate Options:

None

-profile-functions
Inserts instrumentation calls at a
function[aq]s entry and exit points.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
OFF
No instrumentation calls are inserted at a function[aq]s entry and exit points.
Description:

This option inserts instrumentation calls at a function[aq]s entry and exit points within a single-threaded application to collect the cycles spent within the function to produce reports that can help in identifying code hotspots.

When the instrumented application is run, this option causes the generation of a loop_prof_funcs_<name>.dump file, where <name> is a timestamp for the run.

The same data values are also dumped into the file loop_prof_<name>.xml for use with the data viewer application, unless you turn off the output format by setting the environment variable INTEL_LOOP_PROF_XML_DUMP to 0.

Alternate Options:

None

-profile-loops=keyword
Inserts instrumentation calls at a
function[aq]s entry and exit points, and before and after instrumentable loops.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
keyword
Specifies which type of loops should have instrumentation. Possible values are:
inner
Inserts instrumentation before and after inner loops.
outer
Inserts instrumentation before and after outer loops.
all
Inserts instrumentation before and after all loops.
Default:
OFF
No instrumentation calls are inserted at a function[aq]s entry and exit points, or before and after instrumentable loop.
Description:

This option inserts instrumentation calls at a function[aq]s entry and exit points within a single-threaded application. For unthreaded applications, it also inserts instrumentation before and after instrumentable loops of the type listed in keyword.

When the instrumented application is run, this option causes the generation of a loop_prof_funcs_<name>.dump file and a loop_prof_funcs_<name>.dump file, where <name> is a timestamp for the run.

The same timestamp is used for the loop file and function file. This identifies that the loop data and function data were from the same program run.

The same data values are also dumped into the file loop_prof_<name>.xml for use with the data viewer application, unless you turn off the output format by setting the environment variable INTEL_LOOP_PROF_XML_DUMP to 0.

Alternate Options:

None

-profile-loops-report[=n]
Controls the level of detail for the data collected when instrumentation occurs before and after certain loops.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
n
Is a value denoting the level of detail to report. Possible values are:
1
Reports the cycle counts on entry and exits of loops. This is the default if n is not specified.
2
Reports the level 1 default details, but also includes the loop min/max and average loop iteration counts.
To collect the loop iteration counts, additional instrumentation is inserted. This can increase overhead in the instrumented application and slow performance.
Default:
1
The report shows the cycle counts on entry and exits of loops.
Description:

This option controls the level of detail for the data collected when instrumentation occurs before and after certain loops. To use this option, you must also specify option [Q]profile-loops.

The report appears in file loop_prof_loops_<name>.dump, where <name> is a timestamp value for the run. The columns listed in the report will be based on the level of detail that was selected during instrumentation.

It is recommended that the same report level be used for all files that are instrumented for the application. If different files of the application were instrumented with different levels, the report will contain all the columns of the highest detail level, but with default values for unavailable fields for files that were instrumented at lower levels.

Alternate Options:

None

-pthread
Tells the compiler to use pthreads library for multithreading support.
Arguments:

None

Default:
OFF
The compiler does not use pthreads library for multithreading support.
Description:

Tells the compiler to use pthreads library for multithreading support.

Alternate Options:

Linux and OS X: -reentrancy threaded

-Qinstalldir
Specifies the root directory where the compiler installation was performed.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
dir
Is the root directory where the installation was performed.
Default:
OFF
The default root directory for compiler installation is searched for the compiler.
Description:

This option specifies the root directory where the compiler installation was performed. It is useful if you want to use a different compiler or if you did not use the compilervars shell script to set your environment variables.

Alternate Options:

None

-Qlocation,string,dir
Specifies the directory for supporting
tools.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
string
Is the name of the tool.
dir
Is the directory (path) where the tool is located.
Default:
OFF
The compiler looks for tools in a default area.
Description:

This option specifies the directory for supporting tools.

string can be any of the following:

*
f - Indicates the Intel(R) Fortran compiler.
*
fpp (or cpp) - Indicates the Intel(R) Fortran preprocessor or a user-specified (alternate) Fortran preprocessor.
*
asm - Indicates the assembler.
*
link - Indicates the linker.
*
prof - Indicates the profiler.
*
On Windows* systems, the following is also available:
*
masm - Indicates the Microsoft assembler.
*
On Linux* and OS X* systems, the following are also available:
*
as - Indicates the assembler.
*
gas - Indicates the GNU assembler. This setting is for Linux* only.
*
ld - Indicates the loader.
*
gld - Indicates the GNU loader. This setting is for Linux* only.
*
lib - Indicates an additional library.
*
crt - Indicates the crt%.o files linked into executables to contain the place to start execution.

On Windows and OS X* systems, you can also specify a tool command name.

The following shows an example on OS X* systems:

-Qlocation,ld,/usr/bin ! This tells the driver to use /usr/bin/ld for the loader -Qlocation,ld,/usr/bin/gld ! This tells the driver to use /usr/bin/gld as the loader

The following shows an example on Windows* systems:

/Qlocation,link,”c:Program Files ools” ! This tells the driver to use c:Program Files ools


on,link,”c:Program Files oolsmy_link.exe” ! This tells the driver to use c:Program Files oolsmy_link.exe as the loader

Alternate Options:

None

-qoffload[=keyword] (L*X only)
-qno-offload (L*X only)
Lets you specify the mode for offloading or tell the compiler to ignore language constructs for offloading. This option only applies to Intel(R) MIC Architecture. Option -q[no-]offload is the replacement option for -[no-]offload, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
keyword
Specifies the mode for offloading or it disables offloading. Possible values are:
none
Tells the compiler to ignore language constructs for offloading. Warnings are issued by the compiler. This is equivalent to the negative form of the option.
mandatory
Specifies that offloading is mandatory (required). If the target is not available, one of the following occurs:
*
If no STATUS clause is specified for the OFFLOAD directive, the program fails with an error message.
*
If the STATUS clause is specified, the program continues execution on the CPU.
optional
Specifies that offloading is optional (requested). If the target is not available, the program is executed on the CPU, not the target.
Default:
mandatory
The compiler recognizes language constructs for offloading if they are specified. If option -qoffload (Linux*) or /Qoffload (Windows*) is specified with no keyword, the default is mandatory.
Description:

This option lets you specify the mode for offloading or tell the compiler to ignore language constructs for offloading.

Option -q[no-]offload is the replacement option for -[no-]offload, which is deprecated.

If no -qoffload (Linux*) or /Qoffload (Windows*) option appears on the command line, then OFFLOAD directives are processed and:

*
The MANDATORY or OPTIONAL clauses are obeyed if present
*
If no MANDATORY or OPTIONAL clause is present, the offload is mandatory

If any of the following appears on the command line, then OFFLOAD directives are ignored:

*
Linux* OS: -qoffload=none or -qno-offload
*
Windows* OS: /offload:none or /Qoffload-

However, OpenMP* directives for coprocessor control (for example, !$OMP TARGET) are recognized if the [q or Q]openmp option is specified, regardless of whether or not OFFLOAD directives are recognized or ignored.

If keyword mandatory or optional appears for [Q]offload, then OFFLOAD directives are processed and:

*
The MANDATORY or OPTIONAL clauses are obeyed, regardless of the -qoffload (Linux*) or /Qoffload (Windows*) keyword
*
If no MANDATORY or OPTIONAL clause is present, then the -qoffload (Linux*) or /Qoffload (Windows*) keyword is obeyed

If the STATUS clause is specified for an OFFLOAD directive, it affects run-time behavior.

Alternate Options:

None

-qoffload-attribute-target=target-name (L*X only)
Causes the compiler to flag procedures and data objects in the source file with the offload attribute target(mic). This option only applies to Intel(R) MIC Architecture. Option -qoffload-attribute-target is the replacement option for -offload-attribute-target, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
target-name
Is a specific target. The only supported value for this argument is mic.
Default:
OFF
The compiler does not flag procedures and data objects in the source file with the offload attribute target(mic).
Description:

This option causes the compiler to flag procedures and data objects in the source file with the offload attribute target(mic).

This option is similar to using the required individual directive ATTRIBUTES OFFLOAD:MIC to set the attribute target(mic) for all procedures and data objects in the source file.

Individual directive ATTRIBUTES OFFLOAD:MIC embedded in the source takes precedence over this option.

Alternate Options:

None

-qoffload-option,target,tool,"option-list" (L*X only)
Lets you explicitly specify options to be used for the specified target and tool. This option only applies to Intel(R) MIC Architecture. Option -qoffload-option is the replacement option for -offload-option, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
target
Is the target architecture. The only supported value for this argument is mic.
tool
Is the tool that the option-list is associated with. It can be one of the following values: ld, link, as, or compiler.
ld is the linker tool on Linux* OS; link is the linker tool on Windows* OS.
option-list
Is one or more options that are specific to the tool. The quotation mark delimiters are required. Each option in the option-list must be separated by a space.
For tool compiler, use compiler-specific options; for tool ld, use linker-specific options; for tool as, use assembler-specific options. The options for the tools always use the Linux form even when compiling on Windows.
Default:
OFF
The compiler does not pass additional options to the separate tools on the target architecture.
Description:

This option lets you explicitly specify options to be used for the specified target and tool. It can be specified multiple times on the command line.

When building a heterogeneous application, the driver passes all compiler options specified on the command-line to the host compilation and only certain options to the offload compilation. To see a list of options passed to the offload compilation, specify option watch=mic-cmd.

If you want to pass additional options to the offload compilation, or you would like to override the command line options passed to offload compilation, you must use option [q or Q]offload-option to specify the additional or overriding options.

NOTE: If you specify the options I, L, D, or U with the option [q or Q]offload-option, they override any other I, L, D, and U options that are automatically passed from host to offload compilation.

To achieve the overriding effect, the I, L, D, and U options specified using [q or Q]offload-option are placed ahead of the I, L, D, and U options automatically copied over from the host compilation. All other options specified using [q or Q]offload-option are placed after the options copied over from host to offload compilation.

Alternate Options:

None

-qopenmp
-qno-openmp
Enables the parallelizer to generate multi-threaded code based on OpenMP* directives. Option -qopenmp is the replacement option for -openmp, which is deprecated.
Arguments:

None

Default:
-qno-openmp
No OpenMP* multi-threaded code is generated by the compiler.
Description:

This option enables the parallelizer to generate multi-threaded code based on OpenMP* directives. The code can be executed in parallel on both uniprocessor and multiprocessor systems.

If you use this option, multithreaded libraries are used, but option fpp is not automatically invoked.

This option sets option automatic.

This option works with any optimization level. Specifying no optimization (-O0 on Linux* OS or /Od on Windows* OS) helps to debug OpenMP applications.

To ensure that a threadsafe and/or reentrant run-time library is linked and correctly initialized, option [q or Q]openmp should also be used for the link step and for the compilation of the main routine.

NOTE: On OS X* systems, when you enable OpenMP* API, you must also set the DYLD_LIBRARY_PATH environment variable within Xcode* or an error will be displayed.

NOTE: Options that use OpenMP* API are available for both Intel(R) microprocessors and non-Intel microprocessors, but these options may perform additional optimizations on Intel(R) microprocessors than they perform on non-Intel microprocessors. The list of major, user-visible OpenMP constructs and features that may perform differently on Intel(R) microprocessors versus non-Intel microprocessors include: locks (internal and user visible), the SINGLE construct, barriers (explicit and implicit), parallel loop scheduling, reductions, memory allocation, thread affinity, and binding.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

Linux and OS X: -fopenmp

-qopenmp-lib=type
Lets you specify an OpenMP* run-time library to use for linking. Option -qopenmp-lib is the replacement option for -openmp-lib, which is deprecated.
Arguments:
type
Specifies the type of library to use; it implies compatibility levels. Currently, the only possible value is:
compat
Tells the compiler to use the compatibility OpenMP* run-time library (libiomp). This setting provides compatibility with object files created using Microsoft* and GNU* compilers.
Default:
-qopenmp-lib=compat
The compiler uses the compatibility OpenMP* run-time library (libiomp).
Description:

This option lets you specify an OpenMP* run-time library to use for linking.

The compatibility OpenMP run-time libraries are compatible with object files created using the Microsoft* OpenMP run-time library (vcomp) or the GNU OpenMP run-time library (libgomp).

To use the compatibility OpenMP run-time library, compile and link your application using the compat setting for option [q or Q]openmp-lib. To use this option, you must also specify one of the following compiler options:

*
Linux* OS: -qopenmp or -qopenmp-stubs
*
Windows* OS: /Qopenmp or /Qopenmp-stubs

On Windows* systems, the compatibility OpenMP* run-time library lets you combine OpenMP* object files compiled with the Microsoft* C/C++ compiler with OpenMP* object files compiled with the Intel(R) C, Intel(R) C++, or Intel(R) Fortran compilers. The linking phase results in a single, coherent copy of the run-time library.

On Linux* systems, the compatibility Intel OpenMP* run-time library lets you combine OpenMP* object files compiled with the GNU* gcc or gfortran compilers with similar OpenMP* object files compiled with the Intel(R) C, Intel(R) C++, or Intel(R) Fortran compilers. The linking phase results in a single, coherent copy of the run-time library.

You cannot link object files generated by the Intel(R) Fortran compiler to object files compiled by the GNU Fortran compiler, regardless of the presence or absence of the [Q]openmp compiler option. This is because the Fortran run-time libraries are incompatible.

NOTE: The compatibility OpenMP run-time library is not compatible with object files created using versions of the Intel compilers earlier than 10.0.

NOTE: On Windows* OS, this option is processed by the compiler, which adds directives to the compiled object file that are processed by the linker. On Linux* OS and OS X*, this option is processed by the ifort command that initiates linking, adding library names explicitly to the link command.

Alternate Options:

None

-qopenmp-link=library
Controls whether the compiler links to static or dynamic OpenMP* run-time libraries. Option -qopenmp-link is the replacement option for -openmp-link. Both options are deprecated. There is no replacement option.
Arguments:
library
Specifies the OpenMP library to use. Possible values are:
static
Tells the compiler to link to static OpenMP run-time libraries. Note that static OpenMP libraries are deprecated.
dynamic
Tells the compiler to link to dynamic OpenMP run-time libraries.
Default:
-qopenmp-link=dynamic
The compiler links to dynamic OpenMP* run-time libraries. However, if Linux* OS option -static is specified, the compiler links to static OpenMP run-time libraries.
Description:

This option controls whether the compiler links to static or dynamic OpenMP* run-time libraries.

To link to the static OpenMP run-time library (RTL) and create a purely static executable, you must specify -qopenmp-link=static. However, we strongly recommend you use the default setting, -qopenmp-link=dynamic.

NOTE: Compiler options -static-intel and -shared-intel (Linux* OS and OS X*) have no effect on which OpenMP run-time library is linked.

NOTE: On Linux* systems, -qopenmp-link=dynamic cannot be used in conjunction with option -static. If you try to specify both options together, an error will be displayed.

NOTE: On Linux systems, the OpenMP runtime library depends on using libpthread and libc (libgcc when compiled with gcc). Libpthread and libc (libgcc) must both be static or both be dynamic. If both libpthread and libc (libgcc) are static, then the static version of the OpenMP runtime should be used. If both libpthread and libc (libgcc) are dynamic, then either the static or dynamic version of the OpenMP runtime may be used.

Alternate Options:

None

-qopenmp-offload (L*X only)
-qno-openmp-offload (L*X only)
Enables or disables OpenMP* offloading compilation for the TARGET directives. This option only applies to Intel(R) MIC Architecture. Option -qopenmp-offload is the replacement option for -openmp-offload, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
-qno-openmp-offload
OpenMP* offloading compilation is disabled. However, if option [q or Q]openmp is specified, the default is ON and OpenMP offloading compilation is enabled.
Description:

This option enables or disables OpenMP* offloading compilation for the TARGET directives.

You can also use this option if you want to enable or disable the offloading feature with no impact on other OpenMP* features. In this case, no OpenMP runtime library is needed to link and the compiler does not need to generate OpenMP runtime initialization code.

If you specify this option with the [q or Q]openmp option, it can impact other OpenMP* features.

Alternate Options:

None

-qopenmp-simd (L*X only)
-qno-openmp-simd (L*X only)
Enables or disables OpenMP* SIMD compilation. Option -qopenmp-simd is the replacement option for -openmp-simd, which is deprecated.
Arguments:

None

Default:
-qno-openmp-simd
OpenMP* SIMD compilation is disabled. However, if option [q or Q]openmp is specified, the default is ON and OpenMP SIMD compilation is enabled.
Description:

This option enables or disables OpenMP* SIMD compilation.

You can use this option if you want to enable or disable the SIMD support with no impact on other OpenMP features. In this case, no OpenMP runtime library is needed to link and the compiler does not need to generate OpenMP runtime initialization code.

If you specify this option with the [q or Q]openmp option, it can impact other OpenMP features.

Alternate Options:

None

-qopenmp-stubs
Enables compilation of OpenMP* programs in sequential mode. Option -qopenmp-stubs is the replacement option for -openmp-stubs, which is deprecated.
Arguments:

None

Default:
OFF
The library of OpenMP* function stubs is not linked.
Description:

This option enables compilation of OpenMP* programs in sequential mode. The OpenMP directives are ignored and a stub OpenMP library is linked.

Alternate Options:

None

-qopenmp-threadprivate=type (L*X only)
Lets you specify an OpenMP* threadprivate implementation. Option -qopenmp-threadprivate is the replacement option for -openmp-threadprivate, which is deprecated.
Arguments:
type
Specifies the type of threadprivate implementation. Possible values are:
legacy
Tells the compiler to use the legacy OpenMP* threadprivate implementation used in the previous releases of the Intel(R) compiler. This setting does not provide compatibility with the implementation used by other compilers.
compat
Tells the compiler to use the compatibility OpenMP* threadprivate implementation based on applying the thread-local attribute to each threadprivate variable. This setting provides compatibility with the implementation provided by the Microsoft* and GNU* compilers.
Default:
-qopenmp-threadprivate=legacy
The compiler uses the legacy OpenMP* threadprivate implementation used in the previous releases of the Intel compiler.
Description:

This option lets you specify an OpenMP* threadprivate implementation.

The threadprivate implementation of the legacy OpenMP run-time library may not be compatible with object files created using OpenMP run-time libraries supported in other compilers.

To use this option, you must also specify one of the following compiler options:

*
Linux* OS: -qopenmp or -qopenmp-stubs
*
Windows* OS: /Qopenmp or /Qopenmp-stubs

The value specified for this option is independent of the value used for the [q or Q]openmp-lib option.

NOTE: On Windows* OS, if you specify option /Qopenmp-threadprivate:compat, the compiler does not generate threadsafe code for common blocks in an !$OMP THREADPRIVATE directive unless at least one element in the common block is explicitly initialized. For more information, see the article titled: /Qopenmp-threadprivate:compat doesn[aq]t work with uninitialized threadprivate common blocks, which is located in http://intel.ly/1aHhsjc

NOTE: On OS X* systems, legacy is the only type of threadprivate supported. Option -qopenmp-threadprivate is not recognized by the compiler.

Alternate Options:

None

-qopt-args-in-regs[=keyword]
Determines whether calls to routines are optimized by passing arguments in registers instead of on the stack. Option -qopt-args-in-regs is the replacement option for -opt-args-in-regs, which is deprecated.
Architecture Restrictions: Only available on IA-32 architecture
Arguments:
keyword
Specifies whether the optimization should be performed and under what conditions. Possible values are:
none
The optimization is not performed. No arguments are passed in registers. They are put on the stack.
seen
Causes arguments to be passed in registers when they are passed to routines whose definition can be seen in the same compilation unit.
all
Causes arguments to be passed in registers, whether they are passed to routines whose definition can be seen in the same compilation unit, or not. This value is only available on Linux* systems.
Default:
-qopt-args-in-regs=seen
Arguments are passed in registers when they are passed to routines whose definition is seen in the same compilation unit.
Description:

This option determines whether calls to routines are optimized by passing arguments in registers instead of on the stack. It also indicates the conditions when the optimization will be performed.

This option can improve performance for Application Binary Interfaces (ABIs) that require arguments to be passed in memory and compiled without interprocedural optimization (IPO).

Note that on Linux* systems, if all is specified, a small overhead may be paid when calling "unseen" routines that have not been compiled with the same option. This is because the call will need to go through a "thunk" to ensure that arguments are placed back on the stack where the callee expects them.

Alternate Options:

None

-qopt-assume-safe-padding (L*X only)
-qno-opt-assume-safe-padding (L*X only)
Determines whether the compiler assumes that variables and dynamically allocated memory are padded past the end of the object. This option only applies to Intel(R) MIC Architecture. Option -qopt-assume-safe-padding is the replacement option for -opt-assume-safe-padding, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
-qno-opt-assume-safe-padding
The compiler will not assume that variables and dynamically allocated memory are padded past the end of the object. It will adhere to the sizes specified in your program.
Description:

This option determines whether the compiler assumes that variables and dynamically allocated memory are padded past the end of the object.

When you specify option [q or Q]opt-assume-safe-padding, the compiler assumes that variables and dynamically allocated memory are padded. This means that code can access up to 64 bytes beyond what is specified in your program.

The compiler does not add any padding for static and automatic objects when this option is used, but it assumes that code can access up to 64 bytes beyond the end of the object, wherever the object appears in the program. To satisfy this assumption, you must increase the size of static and automatic objects in your program when you use this option.

This option may improve performance of memory operations.

Alternate Options:

None

-qopt-block-factor=n
Lets you specify a loop blocking factor. Option -qopt-block-factor is the replacement option for -opt-block-factor, which is deprecated.
Arguments:
n
Is the blocking factor. It must be an integer. The compiler may ignore the blocking factor if the value is 0 or 1.
Default:
OFF
The compiler uses default heuristics for loop blocking.
Description:

This option lets you specify a loop blocking factor.

Alternate Options:

None

-qopt-dynamic-align
-qno-opt-dynamic-align
Enables or disables dynamic data alignment optimizations. Option -qopt-dynamic-align is the replacement option for -opt-dynamic-align, which is deprecated.
Arguments:

None

Default:
-qopt-dynamic-align
The compiler may generate code dynamically dependent on alignment. It may do optimizations based on data location for the best performance. The result of execution on some algorithms may depend on data layout.
Description:

This option enables or disables dynamic data alignment optimizations.

If you specify -qno-opt-dynamic-align or /Qopt-dynamic-align-, the compiler generates no code dynamically dependent on alignment. It will not do any optimizations based on data location and results will depend on the data values themselves.

When you specify [q or Q]qopt-dynamic-align, the compiler may implement conditional optimizations based on dynamic alignment of the input data. These dynamic alignment optimizations may result in different bitwise results for aligned and unaligned data with the same values.

Dynamic alignment optimizations can improve the performance of vectorized code, especially for long trip count loops. Disabling such optimizations can decrease performance, but it may improve bitwise reproducibility of results, factoring out data location from possible sources of discrepancy.

Alternate Options:

None

-qopt-gather-scatter-unroll=n (L*X only)
-qno-opt-gather-scatter-unroll (L*X only)
Lets you specify an alternative loop
unroll sequence for gather and scatter loops on Intel(R) MIC Architecture. This option only applies to Intel(R) MIC Architecture. Option -qopt-gather-scatter-unroll is the replacement option for -opt-gather-scatter-unroll, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
n
Is the unroll factor for the gather and scatter loops. It must be an integer between 0 and 8. If you specify value 0 for n, it is the same as specifying the negative form of the option.
Default:
-qno-opt-gather-scatter-unroll or
/Qopt-gather-scatter-unroll The compiler uses default heuristics when unrolling gather and scatter loops.
Description:

This option lets you specify an alternative loop unroll sequence for gather and scatter loops on Intel(R) MIC Architecture.

This option may improve performance of gather/scatter operations.

The value of n that provides the best performance is data-dependent.

In cases where the gather/scatter operation accesses data in a small number of cache-lines (such as 1 or 2), the default sequence (using a small value for n) works best. In cases where each individual data item falls in a different cache-line, it may be better to use a large value for n.

Alternate Options:

None

-qopt-jump-tables=keyword
-qno-opt-jump-tables
Enables or disables generation of jump tables for switch statements. Option -qopt-jump-tables is the replacement option for -opt-jump-tables, which is deprecated.
Arguments:
keyword
Is the instruction for generating jump tables. Possible values are:
never
Tells the compiler to never generate jump tables. All switch statements are implemented as chains of if-then-elses. This is the same as specifying -qno-opt-jump-tables (Linux* OS and OS X*) or /Qopt-jump-tables- (Windows* OS).
default
The compiler uses default heuristics to determine when to generate jump tables.
large
Tells the compiler to generate jump tables up to a certain pre-defined size (64K entries).
n
Must be an integer. Tells the compiler to generate jump tables up to n entries in size.
Default:
-qopt-jump-tables=default
The compiler uses default heuristics to determine when to generate jump tables for switch statements.
Description:

This option enables or disables generation of jump tables for switch statements. When the option is enabled, it may improve performance for programs with large switch statements.

Alternate Options:

None

-qopt-malloc-options=n
Lets you specify an alternate algorithm for malloc(). Option -qopt-malloc-options is the replacement option for -opt-malloc-options, which is deprecated.
Arguments:
n
Specifies the algorithm to use for malloc(). Possible values are:
0
Tells the compiler to use the default algorithm for malloc(). This is the default.
1
Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x10000000.
2
Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x40000000.
3
Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=0 and M_TRIM_THRESHOLD=-1.
4
Causes the following adjustments to the malloc() algorithm: M_MMAP_MAX=0, M_TRIM_THRESHOLD=-1, M_TOP_PAD=4096.
Default:
-qopt-malloc-options=0
The compiler uses the default algorithm when malloc() is called. No call is made to mallopt().
Description:

This option lets you specify an alternate algorithm for malloc().

If you specify a non-zero value for n, it causes alternate configuration parameters to be set for how malloc() allocates and frees memory. It tells the compiler to insert calls to mallopt() to adjust these parameters to malloc() for dynamic memory allocation. This may improve speed.

Alternate Options:

None

-qopt-matmul (L*X only)
-qno-opt-matmul (L*X only)
Enables or disables a compiler-generated
Matrix Multiply (matmul) library call. Option -qopt-matmul is the replacement option for -opt-matmul, which is deprecated.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
-qno-opt-matmul
The matmul library call optimization does not occur unless this option is enabled or certain other compiler options are specified (see below).
Description:

This option enables or disables a compiler-generated Matrix Multiply (MATMUL) library call.

The [q or Q]opt-matmul option tells the compiler to identify matrix multiplication loop nests (if any) and replace them with a matmul library call for improved performance. The resulting executable may get additional performance gain on Intel(R) microprocessors than on non-Intel microprocessors.

This option is enabled by default if options O3 and [Q]parallel are specified. To disable this optimization, specify -qno-opt-matmul or /Qopt-matmul-.

This option has no effect unless option O2 or higher is set.

NOTE: Many routines in the MATMUL library are more highly optimized for Intel(R) microprocessors than for non-Intel microprocessors.

Alternate Options:

None

-qopt-mem-layout-trans[=n]
-qno-opt-mem-layout-trans
Controls the level of memory layout
transformations performed by the compiler. Option -qopt-mem-layout-trans is the replacement option for -opt-mem-layout-trans, which is deprecated.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
n
Is the level of memory layout transformations. Possible values are:
0
Disables memory layout transformations. This is the same as specifying -qno-opt-mem-layout-trans (Linux* OS and OS X*) or /Qopt-mem-layout-trans- (Windows* OS).
1
Enables basic memory layout transformations.
2
Enables more memory layout transformations. This is the same as specifying [q or Q]opt-mem-layout-trans with no argument.
3
Enables aggressive memory layout transformations. You should only use this setting if your system has more than 4GB of physical memory per core.
Default:
-qopt-mem-layout-trans=2
The compiler performs moderate memory layout transformations.
Description:

This option controls the level of memory layout transformations performed by the compiler. This option can improve cache reuse and cache locality.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-qopt-multi-version-aggressive
-qno-opt-multi-version-aggressive
Tells the compiler to use aggressive multi-versioning to check for pointer aliasing and scalar replacement. Option -qopt-multi-version-aggressive is the replacement option for -opt-multi-version-aggressive, which is deprecated.
Arguments:

None

Default:
-qno-opt-multi-version-aggressive
The compiler uses default heuristics when checking for pointer aliasing and scalar replacement.
Description:

This option tells the compiler to use aggressive multi-versioning to check for pointer aliasing and scalar replacement. This option may improve performance.

The performance can be affected by certain options, such as /arch or /Qx (Windows OS) or -m or -x (Linux OS and OS X).

Alternate Options:

None

-qopt-prefetch[=n]
-qno-opt-prefetch
Enables or disables prefetch insertion optimization. Option -qopt-prefetch is the replacement option for -opt-prefetch, which is deprecated.
Arguments:
n
Is the level of software prefetching optimization desired. Possible values are:
0
Disables software prefetching. This is the same as specifying -qno-opt-prefetch (Linux* OS and OS X*) or /Qopt-prefetch- (Windows* OS).
1 to 4
Enables different levels of software prefetching. If you do not specify a value for n, the default is 2. Use lower values to reduce the amount of prefetching.
Default:
-qno-opt-prefetch
Prefetch insertion optimization is disabled.
Description:

This option enables or disables prefetch insertion optimization. The goal of prefetching is to reduce cache misses by providing hints to the processor about when data should be loaded into the cache.

On Intel(R) 64 architecture targeting Intel(R) MIC Architecture, option -qopt-prefetch=3 (Linux* OS and OS X*) and /Qopt-prefetch:3 (Windows* OS) are enabled by default if option O2 or higher is set. To disable prefetching at these optimization levels, specify option -qno-opt-prefetch or /Qopt-prefetch-.

This option enables prefetching when higher optimization levels are specified.

Alternate Options:

None

-qopt-prefetch-distance=n1[, n2] (L*X only)
Specifies the prefetch distance to be used for compiler-generated prefetches inside loops. This option only applies to Intel(R) MIC Architecture. Option -qopt-prefetch-distance is the replacement option for -opt-prefetch-distance, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
n1, n2
Is the prefetch distance in terms of the number of (possibly-vectorized) iterations. Possible values are non-negative numbers >=0.
n2 is optional.
n1 = 0 turns off all compiler issued prefetches from memory to L2. n2 = 0 turns off all compiler issued prefetches from L2 to L1. If n2 is specified and n1 > 0, n1 should be >= n2.
Default:
OFF
The compiler uses default heuristics to determine the prefetch distance.
Description:

This option specifies the prefetch distance to be used for compiler-generated prefetches inside loops. The unit (n1 and optionally n2) is the number of iterations. If the loop is vectorized by the compiler, the unit is the number of vectorized iterations.

The value of n1 will be used as the distance for prefetches from memory to L2 (for example, the vprefetch1 instruction). If n2 is specified, it will be used as the distance for prefetches from L2 to L1 (for example, the vprefetch0 instruction).

This option is ignored if option -qopt-prefetch=0 (Linux* OS) or /Qopt-prefetch:0 (Windows* OS) is specified. On Intel(R) MIC Architecture, -qopt-prefetch=3 and /Qopt-prefetch:3 is the default at option levels O2 and above.

Alternate Options:

None

-qopt-prefetch-issue-excl-hint (L*X only)
Supports the prefetchW instruction in Intel(R) microarchitecture code name Broadwell and later.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
The compiler does not support the PREFETCHW instruction for this microarchitecture.
Description:

This option supports the PREFETCHW instruction in Intel(R) microarchitecture code name Broadwell and later.

When you specify this option, you must also specify option [q or Q]opt-prefetch.

The prefetch instruction is merely a hint and does not affect program behavior. If executed, this instruction moves data closer to the processor and invalidates any other cached copy in anticipation of the line being written to in the future.

Alternate Options:

None

-qopt-ra-region-strategy[=keyword]
Selects the method that the register allocator uses to partition each routine into regions. Option -qopt-ra-region-strategy is the replacement option for -opt-ra-region-strategy, which is deprecated.
Arguments:
keyword
Is the method used for partitioning. Possible values are:
routine
Creates a single region for each routine.
block
Partitions each routine into one region per basic block.
trace
Partitions each routine into one region per trace.
loop
Partitions each routine into one region per loop.
default
The compiler determines which method is used for partitioning.
Default:
-qopt-ra-region-strategy=default
The compiler determines which method is used for partitioning. This is also the default if keyword is not specified.
Description:

This option selects the method that the register allocator uses to partition each routine into regions.

When setting default is in effect, the compiler attempts to optimize the tradeoff between compile-time performance and generated code performance.

This option is only relevant when optimizations are enabled (option O1 or higher).

Alternate Options:

None

-qopt-report[=n]
Tells the compiler to generate an optimization report. Option -qopt-report is the replacement option for -opt-report, which is deprecated.
Arguments:
n
(Optional) Indicates the level of detail in the report. You can specify values 0 through 5. If you specify zero, no report is generated. For levels n=1 through n=5, each level includes all the information of the previous level, as well as potentially some additional information. Level 5 produces the greatest level of detail. If you do not specify n, the default is level 2, which produces a medium level of detail.
Default:
OFF
No optimization report is generated.
Description:

This option tells the compiler to generate a collection of optimization report files, one per object; this is the same output produced by option [q or Q]opt-report-per-object.

If you prefer another form of output, you can specify option [q or Q]opt-report-file.

If you specify a level (n) higher than 5, a warning will be displayed and you will get a level 5 report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

For a description of the information that each n level provides, see the Example section in option [q or Q]opt-report-phase.

Alternate Options:

None

-qopt-report-annotate[=keyword]
Enables the annotated source listing feature and specifies its format.
Arguments:
keyword
Specifies the format for the annotated source listing. You can specify one of the following:
text
Indicates that the listing should be in text format. This is the default if you do not specify keyword.
html
Indicates that the listing should be in html format.
Default:
OFF
No annotated source listing is generated
Description:

This option enables the annotated source listing feature and specifies its format. The feature annotates source files with compiler optimization reports.

By default, one annotated source file is output per object. The annotated file is written to the same directory where the object files are generated. If the object file is a temporary file and an executable is generated, annotated files are placed in the directory where the executable is placed. You cannot generate annotated files to a directory of your choosing.

However, you can output annotated listings to stdout, stderr, or to a file if you also specify option [q or Q]opt-report-file.

By default, this option sets option [q or Q]opt-report with default level 2.

The following shows the file extension and listing details for the two possible keywords.

Format
Listing Details
text
The annotated source listing has an .annot extension. It includes line numbers and compiler diagnostics placed after correspondent lines. IPO footnotes are inserted at the end of annotated file.
html
The annotated source listing has an .annot.html extension. It includes line numbers and compiler diagnostics placed after correspondent lines (as the text format does). It also provides hyperlinks in compiler messages, highlighted code syntax, and quick navigation with the routine list. IPO footnotes are displayed as tooltips.
Alternate Options:

None

-qopt-report-annotate-position[=keyword]
Enables the annotated source listing feature and specifies the site where optimization messages appear in the annotated source in inlined cases of loop optimizations.
Arguments:
keyword
Specifies the site where optimization messages appear in the annotated source. You can specify one of the following:
caller
Indicates that the messages should appear in the caller site. This is the default if you do not specify keyword.
callee
Indicates that the messages should appear in the callee site.
both
Indicates that the messages should appear in both the caller and the callee sites.
Default:
OFF
No annotated source listing is generated
Description:

This option enables the annotated source listing feature and specifies the site where optimization messages appear in the annotated source in inlined cases of loop optimizations.

This option enables option [q or Q]opt-report-annotate if it is not explicitly specified.

Alternate Options:

None

-qopt-report-embed
-qno-opt-report-embed
Determines whether special loop information annotations will be embedded in the object file and/or the assembly file when it is generated. Option -qopt-report-embed is the replacement option for -opt-report-embed, which is deprecated.
Arguments:

None

Default:
OFF
When an assembly file is being generated, special loop information annotations will not be embedded in the assembly file.
However, if option -g (Linux* OS and OS X*) or /Zi (Windows* OS) is specified, special loop information annotations will be embedded in the assembly file unless option -qno-opt-report-embed (Linux OS and OS X) or /Qopt-report-embed- (Windows OS) is specified.
Description:

This option determines whether special loop information annotations will be embedded in the object file and/or the assembly file when it is generated. Specify the positive form of the option to include the annotations in the assembly file.

If an object file (or executable) is being generated, the annotations will be embedded in the object file (or executable).

If you use this option, you do not have to specify option [q or Q]opt-report.

Alternate Options:

None

-qopt-report-file=keyword
Specifies that the output for the optimization report goes to a file, stderr, or stdout. Option -qopt-report-file is the replacement option for -opt-report-file, which is deprecated.
Arguments:
keyword
Specifies the output for the report. You can specify one of the following:
filename
Specifies the name of the file where the output should go.
stderr
Indicates that the output should go to stderr.
stdout
Indicates that the output should go to stdout.
Default:
OFF
No optimization report is generated.
Description:

This option specifies that the output for the optimization report goes to a file, stderr, or stdout.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-filter=string
Tells the compiler to find the indicated parts of your application, and generate optimization reports for those parts of your application. Option -qopt-report-filter is the replacement option for -opt-report-filter, which is deprecated.
Arguments:
string
Is the information to search for. The string must appear within quotes. It can take one or more of the following forms: filenamefilename, routinefilename, range [, range]... filename, routine, range [, range]...
If you specify more than one of the above forms in a string, a semicolon must appear between each form. If you specify more than one range in a string, a comma must appear between each range. Optional blanks can follow each parameter in the forms above and they can also follow each form in a string.
filename
Specifies the name of a file to be found. It can include a path.
If you do not specify a path, the compiler looks for the filename in the current working directory.
routine
Specifies the name of a routine to be found. You can include an identifying argument.
The name, including any argument, must be enclosed in single quotes.
The compiler tries to uniquely identify the routine that corresponds to the specified routine name.
It may select multiple routines to analyze, especially if more than one routine has the specified routine name, so the routine cannot be uniquely identified.
range
Specifies a range of line numbers to be found in the file or routine specified. The range must be specified in integers in the form:
first_line_number-last_line_number
The hyphen between the line numbers is required.
Default:
OFF
No optimization report is generated.
Description:

This option tells the compiler to find the indicated parts of your application, and generate optimization reports for those parts of your application. Optimization reports will only be generated for the routines that contain the specified string.

On Linux* OS and OS X*, if you specify both -qopt-report-routine=string1 and -qopt-report-filter=string2, it is treated as -qopt-report-filter=string1;string2. On Windows* OS, if you specify both /Qopt-report-routine:string1 and /Qopt-report-filter:string2, it is treated as/Qopt-report-filter:string1;string2.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-format=keyword
Specifies the format for an optimization report. Option -qopt-report-format is the replacement option for -opt-report-format, which is deprecated.
Arguments:
keyword
Specifies the format for the report. You can specify one of the following:
text
Indicates that the report should be in text format.
vs
Indicates that the report should be in Visual Studio* (IDE) format. The Visual Studio IDE uses the information to visualize the optimization report in the context of your program source code.
Default:
OFF
No optimization report is generated.
Description:

This option specifies the format for an optimization report. If you use this option, you must specify either text or vs.

If you do not specify this option and another option causes an optimization report to be generated, the default format is text.

Specifying vs can change where the output goes in the following cases:

*
If filename is specified for option [q or Q]opt-report-file, output goes to the specified file.
*
If stdout is specified for option [q or Q]opt-report-file, output goes to stdout.
*
If stderr is specified for option [q or Q]opt-report-file, output goes to stderr.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-help
Displays the optimizer phases available for report generation and a short description of what is reported at each level. Option -qopt-report-help is the replacement option for -opt-report-help, which is deprecated.
Arguments:

None

Default:
OFF
No optimization report is generated.
Description:

This option displays the optimizer phases available for report generation using [q or Q]opt-report-phase, and a short description of what is reported at each level. No compilation is performed.

To indicate where output should go, you can specify one of the following options:

*
[q or Q]opt-report-file
*
[q or Q]opt-report-per-object

If you use this option, you do not have to specify option [q or Q]opt-report.

Alternate Options:

None

-qopt-report-names=keyword
Specifies whether mangled or unmangled names should appear in the optimization report.
Arguments:
keyword
Specifies the form for the names. You can specify one of the following:
mangled
Indicates that the optimization report should contain mangled names.
unmangled
Indicates that the optimization report should contain unmangled names.
Default:
OFF
No optimization report is generated.
Description:

This option specifies whether mangled or unmangled names should appear in the optimization report. If you use this option, you must specify either mangled or unmangled.

If this option is not specified, unmangled names are used by default.

If you specify mangled, encoding (also known as decoration) is added to names in the optimization report. This is appropriate when you want to match annotations with the assembly listing.

If you specify unmangled, no encoding (or decoration) is added to names in the optimization report. This is appropriate when you want to match annotations with the source listing.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-per-object
Tells the compiler that optimization report information should be generated in a separate file for each object. Option -qopt-report-per-object is the replacement option for -opt-report-per-object, which is deprecated.
Arguments:

None

Default:
OFF
No optimization report is generated.
Description:

This option tells the compiler that optimization report information should be generated in a separate file for each object.

If you specify this option for a single-file Interprocedural Optimization (IPO) compilation, a file with a .optrpt extension is produced for every object file or assembly file that is generated by the compiler. For a single file compilation, one file is produced for each of the multiple true objects in the compilation. The names used are ipo_out1.optprt, ipo_out2.optrpt, …ipo_outn.optrpt.

The .optrpt files are written to the target directory of the compilation process. If an object or assembly file is explicitly generated, the corresponding .optrpt file is written to the same directory where the object file is generated. If the object file is just a temporary file and an executable is generated, the corresponding .optrpt files are placed in the directory in which the executable is placed.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-phase[=list]
Specifies one or more optimizer phases for which optimization reports are generated. Option -qopt-report-phase is the replacement option for -opt-report-phase, which is deprecated.
Arguments:
list
(Optional) Specifies one or more phases to generate reports for. If you specify more than one phase, they must be separated with commas. The values you can specify are:
cg
The phase for code generation
ipo
The phase for Interprocedural Optimization
loop
The phase for loop nest optimization
offload
The phase for Intel(R) MIC Architecture. This phase has no effect if option -no-qoffload or option /Qoffload- is specified. This phase only applies to Intel(R) MIC Architecture.
openmp
The phase for OpenMP
par
The phase for auto-parallelization
pgo
The phase for Profile Guided Optimization
tcollect
The phase for trace collection
vec
The phase for vectorization
all
All optimizer phases. This is the default if you do not specify list.
Default:
OFF
No optimization report is generated.
Description:

This option specifies one or more optimizer phases for which optimization reports are generated.

Note that phase offload causes the compiler to print a report of the input or output of variables that the host sends to the offload target and variables that the host receives from the target.

For certain phases, you also need to specify other options:

*
If you specify phase par, you must also specify option [Q]parallel.
*
If you specify phase openmp, you must also specify option [q or Q]openmp.

To find all phase possibilities, specify option [q or Q]opt-report-help.

If you use this option, you do not have to specify option [q or Q]opt-report.

However, if you want to get more details for each phase, specify option [q or Q]opt-report along with this option and indicate the level of detail you want by specifying an appropriate value for n. (See also the Example section below.)

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-report-routine=substring
Tells the compiler to generate an optimization report for each of the routines whose names contain the specified substring. Option -qopt-report-routine is the replacement option for -opt-report-routine, which is deprecated.
Arguments:
substring
Is the text (string) to look for.
Default:
OFF
No optimization report is generated.
Description:

This option tells the compiler to generate an optimization report for each of the routines whose names contain the specified substring.

You can also specify a sequence of substrings separated by commas. If you do this, the compiler will generate an optimization report for each of the routines whose name contains one or more of these substrings.

If you use this option, you do not have to specify option [q or Q]opt-report.

When optimization reporting is enabled, the default is -qopt-report-phase=all (Linux* OS and OS X*) or /Qopt-report-phase:all (Windows* OS).

Alternate Options:

None

-qopt-streaming-cache-evict[=n] (L*X only)
Specifies the cache eviction level to be used by the compiler for streaming loads and stores. This option only applies to Intel(R) MIC Architecture. Option -qopt-streaming-cache-evict is the replacement option for -opt-streaming-cache-evict, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
n
Is a value denoting the cache eviction (clevict) level to use for streaming loads and stores. Possible values are:
0
Tells the compiler to use no cache eviction level.
1
Tells the compiler to use the L1 cache eviction level.
2
Tells the compiler to use the L2 cache eviction level.
3
Tells the compiler to use the L1 and L2 cache eviction level. This is the default of you do not specify n.
Default:
2
The compiler uses the L2 cache eviction level.
Description:

This option specifies the cache eviction (clevict) level to be used by the compiler for streaming loads and stores.

Depending on the level used, the compiler will generate clevict0 and/or clevict1 instructions that evict the cache-line (corresponding to the load or the store) from the first-level and second-level caches. These cache eviction instructions will be generated after performing the corresponding load/store operation.

For more information on how to mark loads/stores as streaming, see the description of the VECTOR NONTEMPORAL directive.

Alternate Options:

None

-qopt-streaming-stores=keyword
Enables generation of streaming stores for optimization. Option -qopt-streaming-stores is the replacement option for -opt-streaming-stores, which is deprecated.
Arguments:
keyword
Specifies whether streaming stores are generated. Possible values are:
always
Enables generation of streaming stores for optimization. The compiler optimizes under the assumption that the application is memory bound.
never
Disables generation of streaming stores for optimization. Normal stores are performed.
auto
Lets the compiler decide which instructions to use.
Default:
-qopt-streaming-stores=auto
The compiler decides whether to use streaming stores or normal stores.
Description:

This option enables generation of streaming stores for optimization. This method stores data with instructions that use a non-temporal buffer, which minimizes memory hierarchy pollution.

This option may be useful for applications that can benefit from streaming stores.

Alternate Options:

None

-qopt-subscript-in-range
-qno-opt-subscript-in-range
Determines whether the compiler assumes that there are no "large" integers being used or being computed inside loops. Option -qopt-subscript-in-range is the replacement option for -opt-subscript-in-range, which is deprecated.
Arguments:

None

Default:
-qno-opt-subscript-in-range
The compiler assumes there are "large" integers being used or being computed within loops.
Description:

This option determines whether the compiler assumes that there are no "large" integers being used or being computed inside loops.

If you specify [q or Q]opt-subscript-in-range, the compiler assumes that there are no "large" integers being used or being computed inside loops. A "large" integer is typically > 231.

This feature can enable more loop transformations.

Alternate Options:

None

-qopt-threads-per-core=n (L*X only)
Informs the compiler about the number of hardware threads per core that will be used for an application. This option only applies to Intel(R) MIC Architecture. Option -qopt-threads-per-core is the replacement option for -opt-threads-per-core, which is deprecated.
Architecture Restrictions: Only available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:
n
Is the number of hardware threads per core that the compiler should assume that will be used while executing the application. Possible values are 1, 2, 3, or 4.
Default:
4
Four hardware threads per core are used for the application.
Description:

This option informs the compiler about the number of hardware threads per core that will be used for an application. This enables the compiler to perform better code optimizations (such as instruction scheduling).

You should choose a value for n that is based on how many threads will be used per core while executing the application. For example, if the application is parallelized using OpenMP* API, use the value of n that uses the same number of threads per core as the OpenMP* API affinity setting will use when executing the application code on the Intel(R) Xeon Phi(TM) coprocessor.

This option does not affect the number of threads per core that will be used at run time.

Code compiled with this option can run correctly on any (hardware-supported) number of threads per core.

Alternate Options:

None

-Qoption,string,options
Passes options to a specified tool.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
string
Is the name of the tool.
options
Are one or more comma-separated, valid options for the designated tool.
Note that certain tools may require that options appear within quotation marks (" ").
Default:
OFF
No options are passed to tools.
Description:

This option passes options to a specified tool.

If an argument contains a space or tab character, you must enclose the entire argument in quotation marks (" "). You must separate multiple arguments with commas.

string can be any of the following:

*
fpp (or cpp) - Indicates the Intel(R) Fortran preprocessor or a user-specified (alternate) Fortran preprocessor.
*
asm - Indicates the assembler.
*
link - Indicates the linker.
*
prof - Indicates the profiler.
*
On Windows* systems, the following is also available:
*
masm - Indicates the Microsoft assembler.
*
On Linux* and OS X* systems, the following are also available:
*
as - Indicates the assembler.
*
gas - Indicates the GNU assembler.
*
ld - Indicates the loader.
*
gld - Indicates the GNU loader.
*
lib - Indicates an additional library.
*
crt - Indicates the crt%.o files linked into executables to contain the place to start execution.
Alternate Options:

None

-rcd
Enables fast float-to-integer conversions.
Arguments:

None

Default:
OFF
Floating-point values are truncated when a conversion to an integer is involved.
Description:

This option enables fast float-to-integer conversions. It 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.

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

Alternate Options:

Linux and OS X: None

-real-size size
Specifies the default KIND for real and complex declarations, constants, functions, and intrinsics.
Arguments:
size
Is the size for real and complex declarations, constants, functions, and intrinsics. Possible values are: 32, 64, or 128.
Default:
real-size 32
Default real and complex declarations, constants, functions, and intrinsics are 4 bytes long (REAL(KIND=4) and COMPLEX(KIND=4)).
Description:

This option specifies the default size (in bits) for real and complex declarations, constants, functions, and intrinsics.

Option
Description
real-size 32
Makes default real and complex declarations, constants, functions, and intrinsics 4 bytes long. REAL declarations are treated as single precision REAL (REAL(KIND=4)) and COMPLEX declarations are treated as COMPLEX (COMPLEX(KIND=4)). Real and complex constants of unspecified KIND are evaluated in single precision (KIND=4).
real-size 64
Makes default real and complex declarations, constants, functions, and intrinsics 8 bytes long. REAL declarations are treated as DOUBLE PRECISION (REAL(KIND=8)) and COMPLEX declarations are treated as DOUBLE COMPLEX (COMPLEX(KIND=8)). Real and complex constants of unspecified KIND are evaluated in double precision (KIND=8).
real-size 128
Makes default real and complex declarations, constants, functions, and intrinsics 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)). Real and complex constants of unspecified KIND are evaluated in extended precision (KIND=16).

These compiler options can affect the result type of intrinsic procedures, such as CMPLX, FLOAT, REAL, SNGL, and AIMAG, which normally produce single-precision REAL or COMPLEX results. To prevent this effect, you must explicitly declare the kind type for arguments of such intrinsic procedures.

For example, if real-size 64 is specified, the CMPLX intrinsic will produce a result of type DOUBLE COMPLEX (COMPLEX(KIND=8)). To prevent this, you must explicitly declare any real argument to be REAL(KIND=4), and any complex argument to be COMPLEX(KIND=4).

Alternate Options:
real-size 64
Linux and OS X: -r8, -autodouble
real-size 128
Linux and OS X: -r16
-recursive
-norecursive
Tells the compiler that all routines should be compiled for possible recursive execution.
Arguments:

None

Default:
norecursive
Routines are not compiled for possible recursive execution.
Description:

This option tells the compiler that all routines should be compiled for possible recursive execution. It sets the automatic option.

Alternate Options:

None

-reentrancy keyword
-noreentrancy
Tells the compiler to generate reentrant code to support a multithreaded application.
Arguments:
keyword
Specifies details about the program. Possible values are:
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 same as specifying noreentrancy.
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.
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.
Default:
noreentrancy
The compiler does not generate reentrant code for applications.
Description:

This option tells the compiler to generate reentrant code to support a multithreaded application.

If you do not specify a keyword for reentrancy, it is the same as specifying reentrancy threaded.

To ensure that a threadsafe and/or reentrant run-time library is linked and correctly initialized, option reentrancy threaded should also be used for the link step and for the compilation of the main routine.

Note that if option threads is specified, it sets option reentrancy threaded, since multithreaded code must be reentrant.

Alternate Options:

None

-S
Causes the compiler to compile to an assembly file only and not link.
Arguments:

None

Default:
OFF
Normal compilation and linking occur.
Description:

This option causes the compiler to compile to an assembly file only and not link.

On Linux* and OS X* systems, the assembly file name has a .s suffix. On Windows* systems, the assembly file name has an .asm suffix.

Alternate Options:

Linux and OS X: None

-safe-cray-ptr
Tells the compiler that Cray* pointers do not alias other variables.
Arguments:

None

Default:
OFF
The compiler assumes that Cray pointers alias other variables.
Description:

This option tells the compiler that Cray pointers do not alias (that is, do not specify sharing memory with) other variables.

Alternate Options:

None

-save
Causes variables to be placed in static memory.
Arguments:

None

Default:
-auto-scalar
Scalar variables of intrinsic types INTEGER, REAL, COMPLEX, and LOGICAL are allocated to the run-time stack. Note that the default changes to auto if one of the following options are specified:
*
recursive
*
[q or Q]openmp
Description:

This option saves all variables in static allocation except local variables within a recursive routine and variables declared as AUTOMATIC.

If you want all local, non-SAVEd variables to be allocated to the run-time stack, specify option automatic.

Alternate Options:

Linux and OS X: -noauto

-save-temps
-no-save-temps
Tells the compiler to save intermediate files created during compilation.
Arguments:

None

Default:
Linux* OS and OS X*: -no-save-temps
On Linux and OS X systems, the compiler deletes intermediate files after compilation is completed.
Description:

This option tells the compiler to save intermediate files created during compilation. The names of the files saved are based on the name of the source file; the files are saved in the current working directory.

If option [Q]save-temps is specified, the following occurs:

*
The object .o file (Linux OS and OS X) or .obj file (Windows OS) is saved.
*
The assembler .s file (Linux OS and OS X) or .asm file (Windows OS) is saved if you specified the [Q]use-asm option.
*
The .i or .i90 file is saved if the fpp preprocessor is invoked.

If -no-save-temps is specified on Linux or OS X systems, the following occurs:

*
The .o file is put into /tmp and deleted after calling ld.
*
The preprocessed file is not saved after it has been used by the compiler.

If /Qsave-temps- is specified on Windows systems, the following occurs:

*
The .obj file is not saved after the linker step.
*
The preprocessed file is not saved after it has been used by the compiler.

NOTE: This option only saves intermediate files that are normally created during compilation.

Alternate Options:

None

-scalar-rep
-no-scalar-rep
Enables or disables the scalar replacement optimization done by the compiler as part of loop transformations.
Arguments:

None

Default:
-scalar-rep
Scalar replacement is performed during loop transformation at optimization levels of O2 and above.
Description:

This option enables or disables the scalar replacement optimization done by the compiler as part of loop transformations. This option takes effect only if you specify an optimization level of O2 or higher.

Alternate Options:

None

-shared (L*X only)
Tells the compiler to produce a dynamic shared object instead of an executable.
Arguments:

None

Default:
OFF
The compiler produces an executable.
Description:

This option tells the compiler to produce a dynamic shared object (DSO) instead of an executable. This includes linking in all libraries dynamically and passing -shared to the linker.

You must specify option fpic for the compilation of each object file you want to include in the shared library.

Alternate Options:

None

-shared-intel
Causes Intel-provided libraries to be linked in dynamically.
Arguments:

None

Default:
OFF
Intel(R) libraries are linked in statically, with the exception of Intel[aq]s OpenMP* runtime support library, which is linked in dynamically.
Description:

This option causes Intel-provided libraries to be linked in dynamically. It is the opposite of -static-intel.

This option is processed by the ifort (icc/icpc) command that initiates linking, adding library names explicitly to the link command.

If you specify option -mcmodel=medium or -mcmodel=large, it sets option -shared-intel.

NOTE: On OS X* systems, when you set "Intel Runtime Libraries" to "Dynamic", you must also set the DYLD_LIBRARY_PATH environment variable within Xcode* or an error will be displayed.

Alternate Options:

None

-shared-libgcc (L*X only)
Links the GNU libgcc library dynamically.
Arguments:

None

Default:
-shared-libgcc
The compiler links the libgcc library dynamically.
Description:

This option links the GNU libgcc library dynamically. It is the opposite of option static-libgcc.

This option is processed by the ifort (icc/icpc) command that initiates linking, adding library names explicitly to the link command.

This option is useful when you want to override the default behavior of the static option, which causes all libraries to be linked statically.

Alternate Options:

None

-show=keyword[, keyword...]
Controls the contents of the listing generated when option list is specified.
Arguments:
keyword
Specifies the contents for the listing. Possible values are:
[no]include
Controls whether contents of files added with INCLUDE statements are included when a listing is generated.
[no]map
Controls whether a symbol listing with a line number cross-reference for each routine is       included when a listing is generated.
[no]options
Controls whether a list of compiler options used for the compilation is included when a listing is generated.
Default:
include, map, and options
When a listing is generated, it contains the contents of INCLUDEd files, a symbol list with a line number cross reference, and a list of compiler options used.
Description:

This option controls the contents of the listing generated when option list is specified.

If you specify option show and do not specify option list, the option is ignored.

Alternate Options:

None

-simd
-no-simd
Enables or disables compiler interpretation of SIMD directives.
Arguments:

None

Default:
-simd
SIMD directives are enabled.
Description:

This option enables or disables compiler interpretation of SIMD directives.

To disable interpretation of SIMD directives, specify -no-simd (Linux* OS and OS X*) or /Qsimd- (Windows* OS). Note that the compiler may still vectorize loops based on its own heuristics (leading to generation of SIMD instructions) even when -no-simd (or /Qsimd-) is specified.

To disable all compiler vectorization, use the "-no-vec -no-simd" (Linux* OS and OS X*) or "/Qvec- /Qsimd-" (Windows* OS) compiler options. The option -no-vec (and /Qvec-) disables all auto-vectorization, including vectorization of array notation statements. The option -no-simd (and /Qsimd-) disables vectorization of loops that have SIMD directives.

NOTE: If you specify option -mia32 or option /arch:IA32, SIMD directives are disabled by default. When you specify option -mia32 or option /arch:IA32, vector instructions cannot be used. Therefore, you cannot explicitly enable SIMD directives by specifying option [Q]simd.

Alternate Options:

None

-sox[=keyword[,keyword]] (L*X only)
-no-sox (L*X only)
Tells the compiler to save the compilation options and version number in the executable file. It also lets you choose whether to include lists of certain routines.
Arguments:
keyword
Is the routine information to include. Possible values are:
inline
Includes a list of the routines that were inlined in each object.
profile
Includes a list of the routines that were compiled with the -prof-use option and for which the .dpi file had profile information, and an indication for each as to whether the profile information was USED (matched) or IGNORED (mismatched).
Default:
-no-sox
The compiler does not save these informational strings in the object file.
Description:

This option tells the compiler to save the compilation options and version number in the executable file. It also lets you choose whether to include lists of certain routines. The information is embedded as a string in each object file or assembly output.

If you specify option sox with no keyword, the compiler saves the compiler options and version number used in the compilation of the objects that make up the executable.

When you specify this option, the size of the executable on disk is increased slightly. Each keyword you specify increases the size of the executable. When you link the object files into an executable file, the linker places each of the information strings into the header of the executable. It is then possible to use a tool, such as a strings utility, to determine what options were used to build the executable file.

Alternate Options:

None

-stand [keyword]
-nostand
Tells the compiler to issue compile-time messages for nonstandard language elements.
keyword
Specifies the language to use as the standard. Possible values are:
none
Issues no messages for nonstandard language elements.
f90
Issues messages for language elements that are not standard in Fortran 90.
f95
Issues messages for language elements that are not standard in Fortran 95.
f03
Issues messages for language elements that are not standard in Fortran 2003.
f08
Issues messages for language elements that are not standard in Fortran 2008.
f15
Issues messages for language elements that are not standard in draft Fortran 2015.
Default:
nostand
The compiler issues no messages for nonstandard language elements.
Description:

This option tells the compiler to issue compile-time messages for nonstandard language elements.

If you do not specify a keyword for stand, it is the same as specifying stand f08.

Option
Description
stand none
Tells the compiler to issue no messages for nonstandard language elements. This is the same as specifying nostand.
stand f90
Tells the compiler to issue messages for language elements that are not standard in Fortran 90.
stand f95
Tells the compiler to issue messages for language elements that are not standard in Fortran 95.
stand f03
Tells the compiler to issue messages for language elements that are not standard in Fortran 2003.
stand f08
Tells the compiler to issue messages for language elements that are not standard in Fortran 2008. This option is set if you specify warn stderrors.
stand f15
Tells the compiler to issue messages for language elements that are not standard in draft Fortran 2015.
Alternate Options:
stand none
Linux and OS X: -nostand
stand f90
Linux and OS X: -std90
stand f95
Linux and OS X: -std95
stand f03
Linux and OS X: -std03
stand f08
Linux and OS X: -std08, -stand, -std
stand f15
Linux and OS X: -std15
-standard-semantics
Determines whether the current Fortran Standard behavior of the compiler is fully implemented.
Arguments:

None

Default:
OFF
The compiler implements most but not all of the current Fortran Standard behavior.
Description:

This option determines whether the current Fortran Standard behavior of the compiler is fully implemented.

If you specify option standard-semantics, it enables all of the options that implement the current Fortran Standard behavior of the compiler, which is Fortran 2003 with some Fortran 2008 features.

Option standard-semantics enables option fpscomp logicals and the following settings for option assume: byterecl, fpe_summary, ieee_fpe_flags (if the fp-model option setting is strict or precise), minus0, noold_ldout_format, noold_maxminloc, noold_unit_star, noold_xor, protect_parens, realloc_lhs, std_intent_in, std_minus0_rounding1This is the default setting for this assume option., std_mod_proc_name, and std_value1.

If you specify option standard-semantics and also explicitly specify a different setting for an affected assume option, the value you specify takes effect. It overrides the settings enabled by option standard-semantics.

Alternate Options:

None

-static (L*X only)
Prevents linking with shared libraries.
Arguments:

None

Default:
Linux: OFF Windows: varies
On Linux* systems, the compiler links with shared libraries. On Windows* systems, /static is equivalent to option /MT.
Description:

This option prevents linking with shared libraries. It causes the executable to link all libraries statically.

Alternate Options:

None

-static-intel
Causes Intel-provided libraries to be linked in statically.
Arguments:

None

Default:
ON
Intel libraries are linked in statically, with the exception of Intel[aq]s OpenMP* runtime support library, which is linked in dynamically.
Description:

This option causes Intel-provided libraries to be linked in statically. It is the opposite of -shared-intel.

This option is processed by the ifort (icc/icpc) command that initiates linking, adding library names explicitly to the link command.

If you specify option -static-intel while option -mcmodel=medium or -mcmodel=large is set, an error will be displayed.

If you specify option static-intel and any of the Intel-provided libraries have no static version, a diagnostic will be displayed.

Alternate Options:

None

-staticlib (M*X only)
Invokes the libtool command to generate static libraries.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting Intel(R) MIC Architecture
Arguments:

None

Default:
OFF
The compiler produces an executable.
Description:

This option invokes the libtool command to generate static libraries. This option is processed by the command that initiates linking, adding library names explicitly to the link command.

When passed this option, the compiler uses the libtool command to produce a static library instead of an executable when linking.

To build dynamic libraries, you should specify option -dynamiclib or libtool -dynamic <objects>.

Alternate Options:

None

-static-libgcc (L*X only)
Links the GNU libgcc library statically.
Arguments:

None

Default:
OFF
The compiler links the GNU libgcc library dynamically.
Description:

This option links the GNU libgcc library statically. It is the opposite of option -shared-libgcc.

This option is processed by the ifort (icc/icpc) command that initiates linking, adding library names explicitly to the link command.

This option is useful when you want to override the default behavior, which causes the library to be linked dynamically.

Alternate Options:

None

-static-libstdc++ (L*X only)
Links the GNU libstdc++ library statically.
Arguments:

None

Default:
OFF
The compiler links the GNU libstdc++ library dynamically.
Description:

This option links the GNU libstdc++ library statically. This option is processed by the ifort (icc/icpc) command that initiates linking, adding library names explicitly to the link command.

This option is useful when you want to override the default behavior, which causes the library to be linked dynamically.

Alternate Options:

None

-syntax-only
Tells the compiler to check only for correct syntax.
Arguments:

None

Default:
OFF
Normal compilation is performed.
Description:

This option tells the compiler to check only for correct syntax. It lets you do a quick syntax check of your source file.

Compilation stops after the source file has been parsed. No code is generated, no object file is produced, and some error checking done by the optimizer is bypassed.

Warnings and messages appear on stderr.

Alternate Options:

Linux: -y, -fsyntax-only, -syntax (this is a deprecated option)

OS X: -y, -fsyntax-only

Windows: /Zs

-Tfilename (L*X only)
Tells the linker to read link commands from a file.
Arguments:
filename
Is the name of the file.
Default:
OFF
The linker does not read link commands from a file.
Description:

This option tells the linker to read link commands from a file.

Alternate Options:

None

-tcheck (L*X only)
Enables analysis of threaded
applications.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
OFF
Threaded applications are not instrumented by the compiler for analysis by Intel(R) Thread Checker.
Description:

This option enables analysis of threaded applications.

This thread checking feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-tcollect[lib] (L*X only)
Inserts instrumentation probes calling the Intel(R) Trace Collector API.
Arguments:
lib
Is one of the Intel(R) Trace Collector libraries; for example, VT, VTcs, VTmc, or VTfs. If you do not specify lib, the default library is VT.
Default:
OFF
Instrumentation probes are not inserted into compiled applications.
Description:

This option inserts instrumentation probes calling the Intel(R) Trace Collector API.

This trace analyzing/collecting feature requires installation of another product. For more information, see Feature Requirements.

This option provides a flexible and convenient way of instrumenting functions of a compiled application. For every function, the entry and exit points are instrumented at compile time to let the Intel(R) Trace Collector record functions beyond the default MPI calls. For non-MPI applications (for example, threaded or serial), you must ensure that the Intel(R) Trace Collector is properly initialized (VT_initialize/VT_init).

CAUTION: Be careful with full instrumentation because this feature can produce very large trace files.

Alternate Options:

None

-tcollect-filter filename (L*X only)
Lets you enable or disable the instrumentation of specified functions.
Arguments:
filename
Is a configuration file that lists filters, one per line. Each filter consists of a regular expression string and a switch. Strings with leading or trailing white spaces must be quoted. Other strings do not have to be quoted. The switch value can be ON, on, OFF, or off.
Default:
OFF
Functions are not instrumented. However, if option -tcollect (Linux) is specified, the filter setting is ".* ON" and all functions get instrumented.
Description:

This option lets you enable or disable the instrumentation of specified functions.

During instrumentation, the regular expressions in the file are matched against the function names. The switch specifies whether matching functions are to be instrumented or not. Multiple filters are evaluated from top to bottom with increasing precedence.

The names of the functions to match against are formatted as follows:

*
The source file name is followed by a colon-separated function name. Source file names should contain the full path, if available. For example:
/home/joe/src/file.f:FOO_bar
*
Classes and function names are separated by double colons. For example:
/home/joe/src/file.fpp:app::foo::bar

You can use option [q or Q]opt-report to get a full list of file and function names that the compiler recognizes from the compilation unit. This list can be used as the basis for filtering in the configuration file.

This trace analyzing/collecting feature requires installation of another product. For more information, see Feature Requirements.

Alternate Options:

None

-threads
-nothreads
Tells the linker to search for unresolved references in a multithreaded run-time library.
Arguments:

None

Default:
Windows* OS: threads
The linker searches for unresolved references in a library that supports enabling thread-safe operation when the /reentrancy:threaded option is also specified.
Linux* OS and OS X*: nothreads
The linker searches for unresolved references in a library that does not support thread-safe operation.
Description:

This option tells the linker to search for unresolved references in a multithreaded run-time library.

This option sets option reentrancy threaded.

Windows systems: The following table shows which options to specify for a multithreaded run-time library.

To ensure that a threadsafe and/or reentrant run-time library is linked and correctly initialized, option threads should also be used for the link step and for the compilation of the main routine.

NOTE: On Windows* OS, this option is processed by the compiler, which adds directives to the compiled object file that are processed by the linker. On Linux* OS and OS X*, this option is processed by the ifort command that initiates linking, adding library names explicitly to the link command.

Alternate Options:

None

-traceback
-notraceback
Tells the compiler to generate extra information in the object file to provide source file traceback information when a severe error occurs at run time.
Arguments:

None

Default:
notraceback
No extra information is generated in the object file to produce traceback information.
Description:

This option tells the compiler to generate extra information in the object file to provide source file traceback information when a severe error occurs at run time.

When the severe error occurs, source file, routine name, and line number correlation information is displayed along with call stack hexadecimal addresses (program counter trace).

Note that when a severe error occurs, advanced users can also locate the cause of the error using a map file and the hexadecimal addresses of the stack displayed when the error occurs.

This option increases the size of the executable program, but has no impact on run-time execution speeds.

It functions independently of the debug option.

On Windows* systems, traceback sets the /Oy- option, which forces the compiler to use EBP as the stack frame pointer.

On Windows* systems, the linker places the traceback information in the executable image, in a section named ".trace". To see which sections are in an image, use the command:

link -dump -summary your_app_name.exe

To see more detailed information, use the command:

link -dump -headers your_app_name.exe

On Windows* systems, when requesting traceback, you must set Enable Incremental Linking in the VS .NET* IDE Linker Options to No. You must also set Omit Frame Pointers (the /Oy option) in the Optimization Options to "No."

On Linux* systems, to display the section headers in the image (including the header for the .trace section, if any), use the command:

objdump -h your_app_name.exe

On OS X* systems, to display the section headers in the image, use the command:

otool -l your_app_name.exe

Alternate Options:

None

-Uname
Undefines any definition currently in effect for the specified symbol.
Arguments:
name
Is the name of the symbol to be undefined.
Default:
OFF
Symbol definitions are in effect until they are undefined.
Description:

This option undefines any definition currently in effect for the specified symbol.

On Windows systems, use the /u option to undefine all previously defined preprocessor values.

Alternate Options:

Linux and OS X: None

Windows: /undefine:name

-unroll[=n]
Tells the compiler the maximum number of times to unroll loops.
Arguments:
n
Is the maximum number of times a loop can be unrolled. To disable loop enrolling, specify 0.
Default:
-unroll
The compiler uses default heuristics when unrolling loops.
Description:

This option tells the compiler the maximum number of times to unroll loops.

If you do not specify n, the optimizer determines how many times loops can be unrolled.

Alternate Options:

Linux and OS X: -funroll-loops

-unroll-aggressive
-no-unroll-aggressive
Determines whether the compiler uses more aggressive unrolling for certain loops.
Arguments:

None

Default:
-no-unroll-aggressive
The compiler uses default heuristics when unrolling loops.
Description:

This option determines whether the compiler uses more aggressive unrolling for certain loops. The positive form of the option may improve performance.

This option enables aggressive, complete unrolling for loops with small constant trip counts.

Alternate Options:

None

-v [filename]
Specifies that driver tool commands should be displayed and executed.
Arguments:
filename
Is the name of a source file to be compiled. A space must appear before the file name.
Default:
OFF
No tool commands are shown.
Description:

This option specifies that driver tool commands should be displayed and executed.

If you use this option without specifying a source file name, the compiler displays only the version of the compiler.

If you want to display processing information (pass information and source file names), specify keyword all for the watch option.

Alternate Options:

Linux and OS X: -watch cmd

Windows: /watch:cmd

-vec
-no-vec
Enables or disables vectorization.
Arguments:

None

Default:
-vec
Vectorization is enabled if option O2 or higher is in effect.
Description:

This option enables or disables vectorization.

To disable vectorization, specify -no-vec (Linux* OS and OS X*) or /Qvec- (Windows* OS).

To disable interpretation of SIMD directives, specify -no-simd (Linux* OS and OS X*) or /Qsimd- (Windows* OS).

To disable all compiler vectorization, use the "-no-vec -no-simd" (Linux* OS and OS X*) or "/Qvec- /Qsimd-" (Windows* OS) compiler options. The option -no-vec (and /Qvec-) disables all auto-vectorization, including vectorization of array notation statements. The option -no-simd (and /Qsimd-) disables vectorization of loops that have SIMD directives.

NOTE: Using this option enables vectorization at default optimization levels for both Intel(R) microprocessors and non-Intel microprocessors. Vectorization may call library routines that can result in additional performance gain on Intel microprocessors than on non-Intel microprocessors. The vectorization can also be affected by certain options, such as /arch (Windows OS), -m (Linux OS and OS X), or [Q]x.

Alternate Options:

None

-vec-guard-write
-no-vec-guard-write
Tells the compiler to perform a conditional check in a vectorized loop.
Arguments:

None

Default:
-vec-guard-write
The compiler performs a conditional check in a vectorized loop.
Description:

This option tells the compiler to perform a conditional check in a vectorized loop. This checking avoids unnecessary stores and may improve performance.

Alternate Options:

None

-vec-threshold[n]
Sets a threshold for the vectorization of loops.
Arguments:
n
Is an integer whose value is the threshold for the vectorization of loops. Possible values are 0 through 100.
If n is 0, loops get vectorized always, regardless of computation work volume.
If n is 100, loops get vectorized when performance gains are predicted based on the compiler analysis data. Loops get vectorized only if profitable vector-level parallel execution is almost certain.
The intermediate 1 to 99 values represent the percentage probability for profitable speed-up. For example, n=50 directs the compiler to vectorize only if there is a 50% probability of the code speeding up if executed in vector form.
Default:
-vec-threshold100
Loops get vectorized only if profitable vector-level parallel execution is almost certain. This is also the default if you do not specify n.
Description:

This option sets a threshold for the vectorization of loops based on the probability of profitable execution of the vectorized loop in parallel.

This option is useful 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.

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.

Alternate Options:

None

-vecabi=keyword
Determines whether the compiler uses the compatibility or legacy vector function application binary interface (ABI).
Arguments:
keyword
Specifies which vector function ABI to use. Possible values are:
legacy
Tells the compiler to use the legacy vector function ABI.
compat
Tells the compiler to use the compatibility vector function ABI.
Default:
-vecabi=compat
The compiler uses the compatibility vector function ABI.
Description:

This option determines whether the compiler uses the compatibility or legacy vector function application binary interface (ABI).

On Linux* systems, by default, it provides compatibility with gcc[aq]s version of the vector function ABI. You must specify keywordlegacy if you need to keep the generated vector function binary backward compatible with the vectorized binary generated by the previous version of Intel(R) compilers.

Alternate Options:

None

-vms
-novms
Causes the run-time system to behave like HP* Fortran on OpenVMS* Alpha systems and VAX* systems (VAX FORTRAN*).
Arguments:

None

Default:
novms
The run-time system follows default Intel(R) Fortran behavior.
Description:

This option causes the run-time system to behave like HP* Fortran on OpenVMS* Alpha systems and VAX* systems (VAX FORTRAN*).

It affects the following language features:

*
Certain defaults In the absence of other options, vms sets the defaults as check format and check output_conversion.
*
Alignment Option vms does not affect the alignment of fields in records or items in common blocks. For compatibility with HP Fortran on OpenVMS systems, use align norecords to pack fields of records on the next byte boundary.
*
Carriage control default If option vms and option ccdefault default are specified, carriage control defaults to FORTRAN if the file is formatted and the unit is connected to a terminal.
*
INCLUDE qualifiers /LIST and /NOLIST are recognized at the end of the file name 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. Note that if vms is not specified, the path used is the directory where the file that contains the INCLUDE statement resides.
*
Quotation mark character A quotation mark (") character is recognized as starting an octal constant ("0..7) instead of a character literal ("...").
*
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 1-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: these files are truncated.
*
Implied logical unit numbers The vms option enables Intel(R) Fortran to recognize certain environment variables 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 the 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.
*
OPEN statement effects Carriage control defaults to FORTRAN if the file is formatted, and the unit is connected to a terminal. 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 1 to accommodate the deleted record character.
*
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 (" "), then an ATTACCNON error 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.
Alternate Options:

None

-Wa,option1[,option2,...]
Passes options to the assembler for processing.
Arguments:
option
Is an assembler option. This option is not processed by the driver and is directly passed to the assembler.
Default:
OFF
No options are passed to the assembler.
Description:

This option passes one or more options to the assembler for processing. If the assembler is not invoked, these options are ignored.

Alternate Options:

None

-warn [keyword[, keyword...]]
-nowarn
Specifies diagnostic messages to be issued by the compiler.
Arguments:
keyword
Specifies the diagnostic messages to be issued. Possible values are:
none
Disables all warning messages.
[no]alignments
Determines whether warnings occur for data that is not naturally aligned.
[no]declarations
Determines whether warnings occur for any undeclared names.
[no]errors
Determines whether warnings are changed to errors.
[no]general
Determines whether warning messages and informational messages are issued by the compiler.
[no]ignore_loc
Determines whether warnings occur when %LOC is stripped from an actual argument.
[no]interfaces
Determines whether the compiler checks the interfaces of all SUBROUTINEs called and FUNCTIONs invoked in your compilation against an external set of interface blocks.
[no]stderrors
Determines whether warnings about Fortran standard violations are changed to errors.
[no]truncated_source
Determines whether warnings occur when source exceeds the maximum column width in fixed-format files.
[no]uncalled
Determines whether warnings occur when a statement function is never called
[no]unused
Determines whether warnings occur for declared variables that are never used.
[no]usage
Determines whether warnings occur for questionable programming practices.
all
Enables all warning messages except errors and stderrors.
Default:
alignments
Warnings are issued about data that is not naturally aligned.
general
All information-level and warning-level messages are enabled.
usage
Warnings are issued for questionable programming practices.
nodeclarations
No warnings are issued for undeclared names.
noerrors
Warning-level messages are not changed to error-level messages.
noignore_loc
No warnings are issued when %LOC is stripped from an argument.
nointerfaces
The compiler does not check interfaces of SUBROUTINEs called and FUNCTIONs invoked in your compilation against an external set of interface blocks.
nostderrors
Warning-level messages about Fortran standards violations are not changed to error-level messages.
notruncated_source
No warnings are issued when source exceeds the maximum column width in fixed-format files.
nouncalled
No warnings are issued when a statement function is not called.
nounused
No warnings are issued for variables that are declared but never used.
Description:

This option specifies the diagnostic messages to be issued by the compiler.

Option
Description
warn none
Disables all warning messages. This is the same as specifying nowarn.
warn noalignments
Disables warnings about data that is not naturally aligned.
warn declarations
Enables warnings about any undeclared names. The compiler will use the default implicit data typing rules for such undeclared names. The IMPLICIT and IMPLICIT NONE statements override this option.
warn errors
Tells the compiler to change all warning-level messages to error-level messages; this includes warnings about Fortran standards violations.
warn nogeneral
Disables all informational-level and warning-level diagnostic messages.
warn ignore_loc
Enables warnings when %LOC is stripped from an actual argument.
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 option 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. If interface mismatches occur, some will result in a compile-time error,
others will only generate a warning.
By default, warn interfaces turns on option gen-interfaces. You can turn off that option by explicitly specifying option /gen-interfaces- (Windows* OS) or -no-gen-interfaces (Linux* OS and OS X*).
warn stderrors
Tells the compiler to change all warning-level messages about Fortran standards violations to error-level messages. This option sets the std03 option (Fortran 2003 standard). If you want Fortran 95 standards violations to become errors, you must specify options warn stderrors and std95.
warn truncated_source
Enables warnings when a source line exceeds the maximum column width in fixed-format source files. The maximum column width for fixed-format files is 72, 80, or 132, depending on the setting of the extend-source option. The warn truncated_source option has no effect on truncation; lines that exceed the maximum column width are always truncated. This option does not apply to free-format source files.
warn uncalled
Enables warnings when a statement function is never called.
warn unused
Enables warnings for variables that are declared but never used.
warn nousage
Disables warnings about questionable programming practices. Questionable programming practices, although allowed, often are the result of programming errors; for example: a continued character or Hollerith literal whose first part ends before the statement field and appears to end with trailing spaces. Note that the /pad-source option can prevent this error.
warn all
This is the same as specifying warn. This option does not set options warn errors or warn stderrors. To enable all the additional checking to be performed and force the severity of the diagnostic messages to be severe enough to not generate an object file, specify warn allwarn errors or warn allwarn stderrors.
On Windows systems: In the Property Pages, Custom means that diagnostics will be specified on an individual basis.
Alternate Options:
warn none
Linux and OS X: -nowarn, -w, -W0, -warn nogeneral
warn declarations
Linux and OS X: -implicitnone, -u
warn nodeclarations
Linux and OS X: None
warn general
Linux and OS X: -W1
warn nogeneral
Linux and OS X: -W0, -w, -nowarn, -warn none
warn stderrors
Linux and OS X: -e90, -e95, -e03
warn all
Linux and OS X: -warn
-watch[=keyword[, keyword...]]
-nowatch
Tells the compiler to display certain information to the console output window.
Arguments:
keyword
Determines what information is displayed. Possible values are:
none
Disables cmd and source.
[no]cmd
Determines whether driver tool commands are displayed and executed.
[no]source
Determines whether the name of the file being compiled is displayed.
mic-cmd
Enables display of compiler options that are passed to the offload compilation. This keyword is only available on Intel(R) MIC Architecture.
all
Enables cmd and source.
Default:
nowatch
Pass information and source file names are not displayed to the console output window.
Description:

Tells the compiler to display processing information (pass information and source file names) to the console output window.

Option watchkeyword
Description
none
Tells the compiler to not display pass information and source file names to the console output window. This is the same as specifying nowatch.
cmd
Tells the compiler to display and execute driver tool commands.
source
Tells the compiler to display the name of the file being compiled.
mic-cmd
Tells the compiler to display the compiler options that are passed to the offload compilation. Only the options that are automatically passed are displayed. If this keyword is specified on an architecture other than Intel(R) MIC Architecture, results vary. It may be ignored, have no effect, or produce an error.
all
Tells the compiler to display pass information and source file names to the console output window. This is the same as specifying watch with no keyword. For heterogeneous compilation, the tool commands for the host and the offload compilations will be displayed.
Alternate Options:
watch cmd
Linux and OS X: -v
-WB
Turns a compile-time bounds check into a warning.
Arguments:

None

Default:
OFF
Compile-time bounds checks are errors.
Description:

This option turns a compile-time bounds check into a warning.

Alternate Options:

None

-what
Tells the compiler to display its detailed version string.
Arguments:

None

Default:
OFF
The version strings are not displayed.
Description:

This option tells the compiler to display its detailed version string.

Alternate Options:

None

-Winline
Warns when a function that is declared as inline is not inlined.
Arguments:

None

Default:
OFF
No warning is produced when a function that is declared as inline is not inlined.
Description:

This option warns when a function that is declared as inline is not inlined.

To see diagnostic messages, including a message about why a particular function was not inlined, you should generate an optimization report by specifying option -qopt-report=5.

Alternate Options:

None

-Wl,option1[,option2,...]
Passes options to the linker for processing.
Arguments:
option
Is a linker option. This option is not processed by the driver and is directly passed to the linker.
Default:
OFF
No options are passed to the linker.
Description:

This option passes one or more options to the linker for processing. If the linker is not invoked, these options are ignored.

This option is equivalent to specifying option -Qoption,link,options.

Alternate Options:

None

-Wp,option1[,option2,...]
Passes options to the preprocessor.
Arguments:
option
Is a preprocessor option. This option is not processed by the driver and is directly passed to the preprocessor.
Default:
OFF
No options are passed to the preprocessor.
Description:

This option passes one or more options to the preprocessor. If the preprocessor is not invoked, these options are ignored.

This option is equivalent to specifying option -Qoption,fpp, options.

Alternate Options:

None

-wrap-margin (L*X only)
-no-wrap-margin (L*X only)
Provides a way to disable the right margin wrapping that occurs in Fortran list-directed output.
Arguments:

None

Default:
wrap-margin
The right margin wraps at column 80 if the record length is greater than 80 characters.
Description:

This option provides a way to disable the right margin wrapping that occurs in Fortran list-directed output. By default, when the record being written becomes longer than 80 characters, the record is wrapped to a new record at what is called the "right margin".

Specify -no-wrap-margin (Linux* OS) or /wrap-margin- (Windows* OS) to disable this behavior.

Alternate Options:

None

-xcode
Tells the compiler which processor
features it may target, including which instruction sets and optimizations it may generate.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:
code
Indicates to the compiler a feature set that it may target, including which instruction sets and optimizations it may generate. Many of the following descriptions refer to Intel(R) Streaming SIMD Extensions (Intel(R) SSE) and Supplemental Streaming SIMD Extensions (Intel(R) SSSE). Possible values are:
COMMON-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, as well as the instructions enabled with CORE-AVX2. Optimizes for Intel(R) processors that support Intel(R) AVX-512 instructions.
MIC-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, Intel(R) AVX-512 Exponential and Reciprocal instructions, Intel(R) AVX-512 Prefetch instructions for Intel(R) processors, and the instructions enabled with CORE-AVX2. Optimizes for Intel(R) processors that support Intel(R) AVX-512 instructions.
CORE-AVX512
May generate Intel(R) Advanced Vector Extensions 512 (Intel(R) AVX-512) Foundation instructions, Intel(R) AVX-512 Conflict Detection instructions, Intel(R) AVX-512 Doubleword and Quadword instructions, Intel(R) AVX-512 Byte and Word instructions and Intel(R) AVX-512 Vector Length extensions, as well as the instructions enabled with CORE-AVX2. Optimizes for Intel(R) processors that support Intel(R) AVX-512 instructions.
CORE-AVX2
May generate Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel(R) processors that support Intel(R) AVX2 instructions.
CORE-AVX-I
May generate the RDRND instruction, Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel(R) processors that support the RDRND instruction.
AVX
May generate Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) AVX instructions.
SSE4.2
May generate Intel(R) SSE4 Efficient Accelerated String and Text Processing instructions, Intel(R) SSE4 Vectorizing Compiler and Media Accelerator, and Intel(R) SSE3, SSE2, SSE, and SSSE3 instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) SSE4.2 instructions.
SSE4.1
May generate Intel(R) SSE4 Vectorizing Compiler and Media Accelerator instructions for Intel(R) processors. May generate Intel(R) SSE4.1, SSE3, SSE2, SSE, and SSSE3 instructions for Intel processors that support Intel(R) SSE4.1 instructions.
ATOM_SSE4.2
May generate MOVBE instructions for Intel(R) processors, depending on the setting of option -minstruction (Linux* OS and OS X*) or /Qinstruction (Windows* OS). May also generate Intel(R) SSE4.2, SSE3, SSE2, and SSE instructions for Intel processors. Optimizes for Intel(R) Atom(TM) processors that support Intel(R) SSE4.2 and MOVBE instructions.
ATOM_SSSE3
May generate MOVBE instructions for Intel(R) processors, depending on the setting of option -minstruction (Linux* OS and OS X*) or /Qinstruction (Windows* OS). May also generate SSSE3, Intel(R) SSE3, SSE2, and SSE instructions for Intel processors. Optimizes for Intel(R) Atom(TM) processors that support Intel(R) SSE3 and MOVBE instructions.
SSE3_ATOM and
SSSE3_ATOM These option settings are deprecated. They have the same effect as specifying ATOM_SSSE3.
SSSE3
May generate SSSE3 and Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. Optimizes for Intel processors that support SSSE3 instructions. For OS X* systems, this value is only supported on Intel(R) 64 architecture. This replaces value T, which is deprecated.
SSE3
May generate Intel(R) SSE3, SSE2, and SSE instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) SSE3 instructions. For OS X* systems, this value is only supported on IA-32 architecture.
SSE2
May generate Intel(R) SSE2 and SSE instructions for Intel(R) processors. Optimizes for Intel processors that support Intel(R) SSE2 instructions. This value is not available on OS X* systems.
You can also specify Host. For more information, see option [Q]xHost.
Default:
Windows* systems: None Linux* systems: None OS X* systems using IA-32
architecture: SSE3 OS X* systems using Intel(R) 64 architecture: SSSE3 On Windows systems, if neither /Qx nor /arch is specified, the default is /arch:SSE2.
On Linux systems, if neither -x nor -m is specified, the default is -msse2.
Description:

This option tells the compiler which processor features it may target, including which instruction sets and optimizations it may generate. It also enables optimizations in addition to Intel feature-specific optimizations.

The specialized code generated by this option may only run on a subset of Intel(R) processors.

The resulting executables created from these option code values can only be run on Intel(R) processors that support the indicated instruction set.

The binaries produced by these code values will run on Intel(R) processors that support the specified features.

Do not use code values to create binaries that will execute on a processor that is not compatible with the targeted processor. The resulting program may fail with an illegal instruction exception or display other unexpected behavior.

Compiling the main program with any of the code values produces binaries that display a fatal run-time error if they are executed on unsupported processors, including all non-Intel processors.

Compiler options m and arch produce binaries that should run on processors not made by Intel that implement the same capabilities as the corresponding Intel(R) processors.

The -x and /Qx options enable additional optimizations not enabled with options -m or /arch (nor with options –ax and /Qax).

On Windows* systems, options /Qx and /arch are mutually exclusive. If both are specified, the compiler uses the last one specified and generates a warning. Similarly, on Linux* and OS X* systems, options -x and -m are mutually exclusive. If both are specified, the compiler uses the last one specified and generates a warning.

NOTE: All settings except SSE2 do a CPU check.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-X
Removes standard directories from the include file search path.
Arguments:

None

Default:
OFF
Standard directories are in the include file search path.
Description:

This option removes standard directories from the include file search path. It prevents the compiler from searching the default path specified by the CPATH environment variable.

On Linux* and OS X* systems, specifying -X (or -noinclude) prevents the compiler from searching in /usr/include for files specified in an INCLUDE statement.

You can use this 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.

This option affects fpp preprocessor behavior and the USE statement.

Alternate Options:

Linux and OS X: -nostdinc

-xHost
Tells the compiler to generate
instructions for the highest instruction set available on the compilation host processor.
Architecture Restrictions: Not available on Intel(R) 64 architecture targeting the
Intel(R) Xeon Phi(TM) coprocessor x100 product family (formerly code name Knights Corner)
Arguments:

None

Default:
Windows* systems: None Linux* systems: None OS X* systems using IA-32
architecture: -xSSE3 OS X* systems using Intel(R) 64 architecture: -xSSSE3 On Windows systems, if neither /Qx nor /arch is specified, the default is /arch:SSE2.
On Linux systems, if neither -x nor -m is specified, the default is -msse2.
Description:

This option tells the compiler to generate instructions for the highest instruction set available on the compilation host processor.

The instructions generated by this compiler option differ depending on the compilation host processor.

The following table describes the effects of specifying the [Q]xHost option and it tells whether the resulting executable will run on processors different from the host processor.

Descriptions in the table refer to Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R) Advanced Vector Extensions (Intel(R) AVX), Intel(R) Streaming SIMD Extensions (Intel(R) SSE), and Supplemental Streaming SIMD Extensions (SSSE).

Instruction Set of Host Processor
Effects When the -xHost or /QxHost Compiler Option is Specified
Intel(R) AVX2
When compiling on Intel(R) processors:
Corresponds to option
[Q]xCORE-AVX2. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support Intel(R) AVX2 instructions.
When compiling on non-Intel processors:
Corresponds to option
-march=core-avx2 (Linux OS and OS X) or /arch:CORE-AVX2 (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) AVX2 instructions.. You may see a run-time error if the run-time processor does not support Intel(R) AVX2 instructions.
Intel(R) AVX
When compiling on Intel(R) processors:
Corresponds to option
[Q]xAVX. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support Intel(R) AVX instructions.
When compiling on non-Intel processors:
Corresponds to option
-mavx (Linux OS and OS X) or /arch:AVX (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) AVX instructions. You may see a run-time error if the run-time processor does not support Intel(R) AVX instructions.
Intel(R) SSE4.2
When compiling on Intel(R) processors:
Corresponds to option
[Q]xSSE4.2. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support Intel(R) SSE4.2 instructions.
When compiling on non-Intel processors:
Corresponds to option
-msse4.2 (Linux OS and OS X) or /arch:SSE4.2 (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) SSE4.2 instructions. You may see a run-time error if the run-time processor does not support Intel(R) SSE4.2 instructions.
Intel(R) SSE4.1
When compiling on Intel(R) processors:
Corresponds to option
[Q]xSSE4.1. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support Intel(R) SSE4.1 instructions.
When compiling on non-Intel processors:
Corresponds to option
-msse4.1 (Linux OS and OS X) or /arch:SSE4.1 (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) SSE4.1 instructions. You may see a run-time error if the run-time processor does not support Intel(R) SSE4.1 instructions.
SSSE3
When compiling on Intel(R) processors:
Corresponds to option
[Q]xSSSE3. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support SSSE3 instructions.
When compiling on non-Intel processors:
Corresponds to option
-mssse3 (Linux OS and OS X) or /arch:SSSE3 (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least SSSE3 instructions. You may see a run-time error if the run-time processor does not support SSSE3 instructions.
Intel(R) SSE3
When compiling on Intel(R) processors:
Corresponds to option
[Q]xSSE3. The generated executable will not run on non-Intel processors and it will not run on Intel(R) processors that do not support Intel(R) SSE3 instructions.
When compiling on non-Intel processors:
Corresponds to option
-msse3 (Linux OS and OS X) or /arch:SSE3 (Windows OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) SSE3 instructions. You may see a warning run-time error if the run-time processor does not support Intel(R) SSE3 instructions.
Intel(R) SSE2
When compiling on Intel(R) processors or non-Intel processors:
Corresponds to option
-msse2 (Linux* OS and OS X*) or /arch:SSE2 (Windows* OS). The generated executable will run on Intel(R) processors and non-Intel processors that support at least Intel(R) SSE2 instructions. You may see a run-time error if the run-time processor does not support Intel(R) SSE2 instructions.

For more information on other settings for option [Q]x, see that option description.

Optimization Notice
= = = = = = = = = =
Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.
Notice revision #20110804
= = = = = = = = = =
Alternate Options:

None

-Xlinker option
Passes a linker option directly to the linker.
Arguments:
option
Is a linker option.
Default:
OFF
No options are passed directly to the linker.
Description:

This option passes a linker option directly to the linker. If -Xlinker -shared is specified, only -shared is passed to the linker and no special work is done to ensure proper linkage for generating a shared object. -Xlinker just takes whatever arguments are supplied and passes them directly to the linker.

If you want to pass compound options to the linker, for example "-L $HOME/lib", you must use the following method:

-Xlinker -L -Xlinker $HOME/lib

Alternate Options:

None

-zero
-nozero
Initializes to zero variables of intrinsic type INTEGER, REAL, COMPLEX, or LOGICAL that are not yet initialized. This is a deprecated option. The replacement option is /Qinit:[no]zero or -init=[no]zero.
Arguments:

None

Default:
-nozero
Variables are not initialized to zero.
Description:

This option initializes to zero variables of intrinsic type INTEGER, REAL, COMPLEX, or LOGICAL that are not yet initialized.

Use option [Q]save on the command line to make all local variables specifically marked as SAVE.

Alternate Options:

None

 

PREDEFINED SYMBOLS

The Intel(R) Fortran documentation describes the predefined preprocessor symbols in detail. This section provides a brief summary of the supported symbols.

You can use the -U option to suppress an automatic definition of a preprocessor symbol. This option suppresses any symbol definition currently in effect for the specified name. This option performs the same function as an #undef preprocessor directive.

The following preprocessor symbols are available:

 

Supported Environment Variables

You can customize your system environment by specifying paths where the compiler searches for certain files such as libraries, include files, configuration files, and certain settings.  

Compiler Compile-Time Environment

Variables

The following table shows the compile-time environment variables that affect the compiler:

Compile-Time Environment Variable
Description
IFORTCFG
Specifies a configuration file that the compiler should use instead of the default configuration file.
By default, the compiler uses the default
configuration file (ifort.cfg) from the same directory where the compiler executable resides.
INTEL_LICENSE_FILE
Specifies the location for the Intel license file.
__INTEL_PRE_FFLAGS
__INTEL_POST_FFLAGS
Specifies a set of compiler options to add to the compile line.
This is an extension to the facility already provided in the
compiler configuration file ifort.cfg.

NOTE: By default, a configuration file named ifort.cfg is used. This file is in the same directory as the compiler executable. To use another configuration file in another location, you can use the IFORTCFG environment variable to assign the directory and file name for the configuration file.
You can insert command line options in the prefix position
using __INTEL_PRE_FFLAGS, or in the suffix position using __INTEL_POST_FFLAGS. The command line is built as follows:
Syntax:ifort<PRE flags>
<flags from configuration file> <flags from the compiler invocation> <POST flags>

NOTE: The driver issues a warning that the compiler is overriding an option because of an environment variable, but only when you include the option /W5 (Windows*) or -w3 (Linux* and OS X*).

PATH
Specifies the directories the system searches for binary executable files.
TMP
TMPDIR
TEMP
Specifies the location for temporary files. If none of these are specified, or writeable, or found, the compiler stores temporary files in /tmp (Linux, OS X) or the current directory (Windows).
On Windows* and OS X*, The compiler
searches for these variables in the following order: TMP, TMPDIR, and TEMP.
On Linux*, The compiler searches for
these variables in the following order: TMPDIR, TMP, and TEMP.
LD_LIBRARY_PATH (Linux*)
Specifies the location for shared objects (.so files).
DYLD_LIBRARY_PATH (OS X*)
Specifies the path for dynamic libraries.
LIB
Specifies the directories for all libraries used by the compiler and linker.
Intel(R) MIC Architecture Environment Variables
MIC_LIBRARY_PATH
Specifies the location on the host for target-specific static libraries. LIBRARY_PATH specifies the location on the host for host-specific static libraries.
GNU Environment Variables
and Extensions
CPATH (Linux* and OS X*)
Specifies the path for include and module files.
GCCROOT (Linux*)
Specifies the location of the gcc* binaries.
Set this variable only when the compiler
cannot locate the gcc binaries when using the -gcc-name option.
GXX_INCLUDE (Linux*)
Specifies the location of the gcc headers. Set this variable to specify the locations of the gcc installed files when the compiler does not find the needed values as specified by the use of -gcc-name=directory-name/gcc or -gxx-name=directory-name/g++.
GXX_ROOT (Linux*)
Specifies the location of the gcc binaries. Set this variable to specify the locations of the gcc installed files when the compiler does not find the needed values as specified by the use of -gcc-name=directory-name/gcc or -gxx-name=directory-name/g++.
LIBRARY_PATH (Linux* and OS X*)
Specifies the path for libraries to be used during the link phase. haha
 

Compiler Run-Time Environment

Variables

The Intel(R) Fortran Compiler run-time system recognizes a number of environment variables. These variables can be used to customize run-time diagnostic error reporting, allow program continuation under certain conditions, disable the display of certain dialog boxes under certain conditions, and allow just-in-time debugging.

Environment variables relating to file I/O are interpreted when the file is opened. Other variables are read when the program starts.

The order of precedence for run-time environment variables is:

1)
OPEN keyword
2)
Environment variable(s)
3)
Command line option

For Fortran runtime environment variables that are boolean (either enabled or disabled), the following tables describe values you can use to enable or disable them. These rules do not apply to environment variables for OpenMP* (OMP_) and their extensions (KMP_), PGO, or Intel(R) MIC Architecture.

Setting a Run-Time Environment Variable to ON or OFF
Examples
An integer composed entirely of digits enables the
environment variable. 1
4938493848
A string starting with
t or T, y or Y, enables the environment variable.
Because you cannot include quotes, or spaces preceding the
string, " T" and [aq] YES[aq] do not work, because both spaces and quotation marks are considered letters. T
t
TRUE
TFALSE
Y
y
yes
yeti
Anything that doesn[aq]t enable the environment variable
disables it. 0
-1
+1
<no value set>

The following table summarizes compiler environment variables that are recognized at run time.

Run-Time Environment Variable
Description
decfort_dump_flag
Boolean.
When set to TRUE, a core dump will be taken when any severe
Intel(R) Fortran run-time error occurs.
Default: FALSE
F_UFMTENDIAN
This variable specifies the numbers of the units to be used for little-endian-to-big-endian conversion purposes.
The variable is retrieved once when the first unit is
opened, and then checked for every open.
FOR_FMT_TERMINATOR
This variable specifies the numbers of the units to have a specific record terminator.
The variable is retrieved once when the first unit is
opened, and then checked for every open.
FORT_FMT_NO_WRAP_MARGIN
Boolean.
When set to TRUE, disables column
wrapping in Fortran list-directed output when the record being written is longer than 80 characters.

NOTE: There is no mechanism to set a value for the right margin, this only disables wrapping.

Default: FALSE (Wrap margin)
FOR_ACCEPT
The ACCEPT statement does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the FOR_ACCEPT environment variable. If FOR_ACCEPT is not defined, the code ACCEPT f,iolist reads from CONIN$ (standard input). If FOR_ACCEPT is defined (as a file name optionally containing a path), the specified file would be read.
FOR_DEBUGGER_IS_PRESENT
Boolean.
When set to TRUE, this variable tells the
Fortran run-time library that your program is executing under a debugger, and generates debug exceptions whenever severe or continuable errors are detected.
On
Linux* and OS X*, this variable must be set for debug exceptions. Setting this variable to TRUE when a program is not executing under a debugger causes unpredictable behavior.
Default: FALSE
FOR_DIAGNOSTIC_LOG_FILE
If this variable is set to the name of a file, diagnostic output is written to the specified file.
The Fortran run-time system attempts to
open that file (append output) and write the error information (ASCII text) to the file.
Because the setting of
FOR_DIAGNOSTIC_LOG_FILE is independent of FOR_DISABLE_DIAGNOSTIC_DISPLAY, you can disable the screen display of information but still capture the error information in a file. Because the text string you assign for the file name is used literally, you must specify the full name. If the file open fails, no error is reported and the run-time system continues diagnostic processing.
FOR_DISABLE_DIAGNOSTIC_DISPLAY
Boolean.
When set to TRUE, this variable disables
the display of all error information. This variable is helpful if you just want to test the error status of your program and do not want the Fortran run-time system to display any information about an abnormal program termination.
FOR_FORCE_STACK_TRACE
Boolean.
When set to TRUE, this variable forces a
traceback to follow any run-time diagnostic message.
If
FOR_DISABLE_STACK_TRACE is also set, FOR_FORCE_STACK_TRACE takes precedence over FOR_DISABLE_STACK_TRACE
Default: FALSE
FOR_DISABLE_STACK_TRACE
Boolean.
When set to TRUE, this variable disables
the call stack trace information that typically follows the displayed severe error message text.
The Fortran run-time error message is
displayed regardless of whether FOR_DISABLE_STACK_TRACE is set to TRUE. If the program is executing under a debugger, the automatic output of the stack trace information by the Fortran library will be disabled to reduce noise. Use the debugger[aq]s stack trace facility to view the stack trace.
Default: FALSE
FOR_IGNORE_EXCEPTIONS
Boolean.
When set to TRUE, this variable disables
default run-time exception handling to allow, for example, just-in-time debugging. The run-time system exception handler returns EXCEPTION_CONTINUE_SEARCH to the operating system, which looks for other handlers to service the exception.
Default: FALSE
FOR_NOERROR_DIALOGS
Boolean.
When set to TRUE, this variable disables
the display of dialog boxes when certain exceptions or errors occur. This is useful when running many test programs in batch mode to prevent a failure from stopping execution of the entire test stream.
Default: FALSE
FOR_PRINT
Neither the PRINT statement nor a WRITE statement with an asterisk (*) in place of a unit number includes an explicit logical unit number. Instead, both use an implicit internal logical unit number and the FOR_PRINT environment variable. If FOR_PRINT is not defined, the code PRINT f,iolist or WRITE (*,f) iolist writes to CONOUT$ (standard output). If FOR_PRINT is defined (as a file name optionally containing a path), the specified file would be written to.
FOR_READ
A READ statement that uses an asterisk (*) in place of a unit number does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the FOR_READ environment variable. If FOR_READ is not defined, the code READ (*,f) iolist or READ f,iolist reads from CONIN$ (standard input). If FOR_READ is defined (as a file name optionally containing a path), the specified file would be read.
FOR_TYPE
The TYPE statement does not include an explicit logical unit number. Instead, it uses an implicit internal logical unit number and the FOR_TYPE environment variable. If FOR_TYPE is not defined, the code TYPE f,iolist writes to CONOUT$ (standard output). If FOR_TYPE is defined (as a file name optionally containing a path), the specified file would be written to.
FORT_BLOCKSIZE
Specifies the default BLOCKSIZE value to be used when BLOCKSIZE= is omitted on the OPEN statement. Valid values are 0 to 2147467264. Sizes are rounded up to the next 512-byte boundary.
This variable applies to all Fortran I/O units except
stderr, which is never buffered.
The variable is retrieved once at program initialization,
and checked for each unit open.
FORT_BUFFERCOUNT
Specifies the default BUFFERCOUNT value to be used when BUFFERCOUNT= is omitted on the OPEN statement. Valid values are 0 to 127. If set to 0, the default value of 1 is used.
This variable applies to all Fortran I/O units except stdout
(units * and 6) and stderr.
The variable is retrieved once at program initialization,
and checked for each unit open.
FORT_BUFFERED
Boolean.
When set to TRUE, this variable specifies
that buffered I/O should be used at run time for input and output on all Fortran I/O units, except stdout (units * and 6). Output to stderr is never buffered.
Default: FALSE
FORT_BUFFERING_THRESHOLD=n
Specifies dynamic buffering for unformatted sequential READ operations:
*
I/O list items with a size <=n are buffered and are moved one at a time from the buffer to the I/O list item.
*
I/O list items with a size >n are not buffered and are moved one at a time from the file to the I/O list item.
FORT_CONVERTn
Specifies the data format for an unformatted file associated with a particular unit number (n).
FORT_CONVERT.ext and
FORT_CONVERT_ext Specifies the data format for unformatted files with a particular file extension suffix (.ext).
FORT_FMT_RECL
Specifies the default record length (normally 132 bytes) for formatted files.
The variable is retrieved once at program initialization,
and checked for each unit open.
FORT_UFMT_RECL
Specifies the default record length (normally 2040 bytes) for unformatted files.
The variable is retrieved once at program initialization,
and checked for each unit open.
FORTn
Specifies 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 the compiler option fpscomp with option keyword filesfromcmd was not specified. Preconnected files attached to units 0, 5, and 6 are associated with system standard I/O files by default.
NLSPATH (Linux* and OS X*)
Specifies the path for the Intel(R) Fortran run-time error message catalog.
TBK_ENABLE_VERBOSE_STACK_TRACE
Boolean.
When set to TRUE, traceback output
displays more detailed call stack information in the event of an error.
The default brief output is usually
sufficient to determine where an error occurred. Brief output includes up to twenty stack frames, reported one line per stack frame. For each frame, the image name containing the PC, routine name, line number, and source file are given.
The verbose output, if selected, will
provide the exception context record (in addition to the information in brief output) if the error was a machine exception (machine register dump), and for each frame, the return address, frame pointer and stack pointer and possible parameters to the routine. This output can be quite long (limited to 16K bytes) and use of the environment variable FOR_DIAGNOSTIC_LOG_FILE is recommended if you want to capture the output accurately. Most situations should not require the use of verbose output.
Default: FALSE
TBK_FULL_SRC_FILE_SPEC
Boolean.
When set to TRUE, traceback output
displays complete file name information including the path. By default, the traceback output displays only the file name and extension in the source file field.
Default: FALSE
FORT_TMPDIR
TMP
TMPDIR
TEMP
Specifies an alternate working directory where scratch files are created.
GNU extensions (recognized
by the Intel(R) OpenMP compatibility library)
GOMP_CPU_AFFINITY (Linux*)
GNU extension recognized by the Intel(R) OpenMP compatibility library. Specifies a list of OS processor IDs.
You must set this environment variable before the first
parallel region or before certain API calls including omp_get_max_threads(), omp_get_num_procs() and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface.
Default: Affinity is disabled
GOMP_STACKSIZE (Linux*)
GNU extension recognized by the Intel(R) OpenMP compatibility library. Same as OMP_STACKSIZE.KMP_STACKSIZE overrides GOMP_STACKSIZE, which overrides OMP_STACKSIZE.
Default: See the description for
OMP_STACKSIZE.
OpenMP* Environment Variables (OMP_) and Extensions
(KMP_)
OMP_CANCELLATION
Activates cancellation of the innermost enclosing region of the type specified. If set to true, the effects of the cancel construct and of cancellation points are enabled and cancellation is activated. If set to false, cancellation is disabled and the cancel construct and cancellation points are effectively ignored.

NOTE: Internal barrier code will work differently depending on whether the cancellation is enabled. Barrier code should repeatedly check the global flag to figure out if the cancellation had been triggered. If a thread observes the cancellation it should leave the barrier prematurely with the return value 1 (may wake up other threads). Otherwise, it should leave the barrier with the return value 0.
Enables (true) or disables (false) cancellation of the innermost
enclosing region of the type specified.
Default: FALSE
Example:
OMP_CANCELLATION=true
OMP_DYNAMIC
Enables (true) or disables (false) the dynamic adjustment of the number of threads.
Default: FALSE
Example:OMP_DYNAMIC=true
OMP_MAX_ACTIVE_LEVELS
The maximum number of levels of parallel nesting for the program.
Default: 1
Syntax:OMP_MAX_ACTIVE_LEVELS=true
OMP_NESTED
Enables (true) or disables (false) nested parallelism.
Default: FALSE
Example:OMP_NESTED=true
OMP_NUM_THREADS
Sets the maximum number of threads to use for OpenMP* parallel regions if no other value is specified in the application.
The value can be a single integer, in
which case it specifies the number of threads for all parallel regions. The value can also be a comma-separated list of integers, in which case each integer specifies the number of threads for a parallel region at a nesting level.
The first position in the list represents
the outer-most parallel nesting level, the second position represents the next-inner parallel nesting level, and so on. At any level, the integer can be left out of the list. If the first integer in a list is left out, it implies the normal default value for threads is used at the outer-most level. If the integer is left out of any other level, the number of threads for that level is inherited from the previous level.
This environment variable applies to the
options Qopenmp (Windows) or qopenmp (Linux and OS X), or Qparallel (Windows) or qparallel (Linux and OS X..
Default: The number of processors
visible to the operating system
Syntax:OMP_NUM_THREADS=value[,value]*
OMP_PLACES
Specifies an explicit ordered list of places, either as an abstract name describing a set of places or as an explicit list of places described by nonnegative numbers. An exclusion operator “!” can also be used to exclude the number or place immediately following the operator.
For
explicit lists, the meaning of the numbers and how the numbering is done for a list of nonnegative numbers are implementation defined. Generally, the numbers represent the smallest unit of execution exposed by the execution environment, typically a hardware thread.
Intervals can be specified using the
<lower-bound> : <length> : <stride> notation to represent the following list of numbers:

"<lower-bound>, <lower-bound> + <stride>, ..., <lower-bound> +(<length>-1)*<stride>."

When <stride> is omitted, a unit stride is assumed. Intervals can specify numbers within a place as well as sequences of places.

# EXPLICIT LIST EXAMPLE setenv OMP_PLACES "{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15}" setenv OMP_PLACES "{0:4},{4:4},{8:4},{12:4}" setenv OMP_PLACES "{0:4}:4:4"

The
abstract names listed below should be understood by the execution and runtime environment:
*
threads: Each place corresponds to a single hardware thread on the target machine.
*
cores: Each place corresponds to a single core (having one or more hardware threads) on the target machine.
*
sockets: Each place corresponds to a single socket (consisting of one or more cores) on the target machine.
When requesting fewer places or more resources than
available on the system, the determination of which resources of type abstract_name are to be included in the place list is implementation-defined. The precise definitions of the abstract names are implementation defined. An implementation may also add abstract names as appropriate for the target platform. The abstract name may be appended by a positive number in parentheses to denote the length of the place list to be created, that is abstract_name(num-places).

# ABSTRACT NAMES EXAMPLE setenv OMP_PLACES threads setenv OMP_PLACES threads(4)

NOTE: If any numerical values cannot be mapped to a processor on the target platform the behavior is implementation-defined. The behavior is also implementation-defined when the OMP_PLACES environment variable is defined using an abstract name.

OMP_PROC_BIND (Windows, Linux)
Sets the thread affinity policy to be used for parallel regions at the corresponding nested level. Enables (true) or disables (false) the binding of threads to processor contexts. If enabled, this is the same as specifying KMP_AFFINITY=scatter. If disabled, this is the same as specifying KMP_AFFINITY=none.
Acceptable values:True,
false, or a comma separated list, each element of which is one of the following values: master, close, spread.
Default:
False
If set to false, the execution environment may move OpenMP*
threads between OpenMP* places, thread affinity is disabled, and proc_bind clauses on parallel constructs are ignored. Otherwise, the execution environment should not move OpenMP* threads between OpenMP* places, thread affinity is enabled, and the initial thread is bound to the first place in the OpenMP* place list.
If set to
master, all threads are bound to the same place as the master thread. If set to close, threads are bound to successive places, close to where the master thread is bound. If set to spread, the master thread[aq]s partition is subdivided and threads are bound to single place successive sub-partitions.

NOTE: KMP_AFFINITY takes precedence over GOMP_CPU_AFFINITY and OMP_PROC_BIND. GOMP_CPU_AFFINITY takes precedence over OMP_PROC_BIND.

OMP_SCHEDULE
Sets the run-time schedule type and an optional chunk size.
Default:STATIC, no chunk
size specified
Example syntax:OMP_SCHEDULE="kind[,chunk_size]"
= = = = = = = = = =

NOTE: Some environment variables are available for both Intel(R) microprocessors and non-Intel microprocessors, but may perform additional optimizations for Intel(R) microprocessors than for non-Intel microprocessors. = = = = = = = = = =

OMP_STACKSIZE
Sets the number of bytes to allocate for each OpenMP* thread to use as the private stack for the thread. Recommended size is 16M.
Use the optional suffixes to specify byte
units: B (bytes), K (Kilobytes), M (Megabytes), G (Gigabytes), or T (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be K (Kilobytes).
This variable does not affect the native
operating system threads created by the user program, or the thread executing the sequential part of an OpenMP* program or parallel programs created using the option Qparallel (Windows) or qparallel (Linux and OS X).
The
kmp_{set,get}_stacksize_s() routines set/retrieve the value. The kmp_set_stacksize_s() routine must be called from sequential part, before first parallel region is created. Otherwise, calling kmp_set_stacksize_s() has no effect.
Default (IA-32 architecture): 2M
Default (Intel(R) 64 architecture):
4M
Default (Intel(R) MIC
architecture):4M (on supported OSes)
Related environment variables:KMP_STACKSIZE
(overrides OMP_STACKSIZE).
Syntax:OMP_STACKSIZE=value
OMP_THREAD_LIMIT
Limits the number of simultaneously-executing threads in an OpenMP* program.
If this limit is reached and another
native operating system thread encounters OpenMP* API calls or constructs, the program can abort with an error message. If this limit is reached when an OpenMP* parallel region begins, a one-time warning message might be generated indicating that the number of threads in the team was reduced, but the program will continue.
This environment variable is only used
for programs compiled with the following options: Qopenmp (Windows) or qopenmp (Linux and OS X), or Qparallel (Windows) or qparallel (Linux and OS X).
The
omp_get_thread_limit() routine returns the value of the limit.
Default: No enforced limit
Related environment variable:KMP_ALL_THREADS (overrides
OMP_THREAD_LIMIT).
Example syntax:OMP_THREAD_LIMIT=value
OMP_WAIT_POLICY
Decides whether threads spin (active) or yield (passive) while they are waiting.
OMP_WAIT_POLICY=ACTIVE
is an alias for KMP_LIBRARY=turnaround, and OMP_WAIT_POLICY=PASSIVE is an alias for KMP_LIBRARY=throughput.
Default:
Passive
Syntax:OMP_WAIT_POLICY=value
KMP_AFFINITY (Windows, Linux)
Enables run-time library to bind threads to physical processing units.
You must set this environment variable before the first
parallel region, or certain API calls including omp_get_max_threads(), omp_get_num_procs() and any affinity API calls. For detailed information on this environment variable, see Thread Affinity Interface.
Default:
noverbose,warnings,respect,granularity=core,duplicates,none
Default (Intel(R) MIC
architecture): noverbose,warnings,respect,granularity=fine,duplicates,scatter,0,0
= = = = = = = = = =

NOTE: Some environment variables are available for both Intel(R) microprocessors and non-Intel microprocessors, but may perform additional optimizations for Intel(R) microprocessors than for non-Intel microprocessors. = = = = = = = = = =

KMP_ALL_THREADS
Limits the number of simultaneously-executing threads in an OpenMP* program. If this limit is reached and another native operating system thread encounters OpenMP* API calls or constructs, then the program may abort with an error message. If this limit is reached at the time an OpenMP* parallel region begins, a one-time warning message may be generated indicating that the number of threads in the team was reduced, but the program will continue execution.
This environment variable is only used
for programs compiled with the qopenmp option.
Default: No enforced limit.
KMP_BLOCKTIME
Sets the time, in milliseconds, that a thread should wait, after completing the execution of a parallel region, before sleeping.
Use the optional character suffixes:
s (seconds), m (minutes), h (hours), or d (days) to specify the units.
Specify
infinite for an unlimited wait time.
Default: 200 milliseconds
Related Environment Variable:KMP_LIBRARY
environment variable.
KMP_CPUINFO_FILE
Specifies an alternate file name for a file containing the machine topology description. The file must be in the same format as /proc/cpuinfo.
Default: None
= = = = = = = = = =

NOTE: Some environment variables are available for both Intel(R) microprocessors and non-Intel microprocessors, but may perform additional optimizations for Intel(R) microprocessors than for non-Intel microprocessors. = = = = = = = = = =

KMP_DETERMINISTIC_REDUCTION
Enables (true) or disables (false) the use of a specific ordering of the reduction operations for implementing the reduction clause for an OpenMP* parallel region. This has the effect that, for a given number of threads, in a given parallel region, for a given data set and reduction operation, a floating point reduction done for an OpenMP* reduction clause has a consistent floating point result from run to run, since round-off errors are identical.
Default:false
KMP_DYNAMIC_MODE
Selects the method used to determine the number of threads to use for a parallel region when OMP_DYNAMIC=true. Possible values: (asat | load_balance | thread_limit), where,
*
asat: estimates number of threads based on parallel start time;

NOTE: Support for asat (automatic self-allocating threads) is now deprecated and will be removed in a future release.

*
load_balance: tries to avoid using more threads than available execution units on the machine;
*
thread_limit: tries to avoid using more threads than total execution units on the machine.
Default (IA-32 architecture):load_balance (on all supported OSes)
Default (Intel(R) 64 architecture):load_balance (on all supported OSes)
Default (Intel(R) MIC
architecture): thread_limit (on supported OSes)
KMP_HOT_TEAMS_MAX_LEVEL
Sets the maximum nested level to which teams of threads will be hot.

NOTE: A hot team is a team of threads optimized for faster reuse by subsequent parallel regions. In a hot team, threads are kept ready for execution of the next parallel region, in contrast to the cold team, which is freed after each parallel region, with its threads going into a common pool of threads.

For values of 2 and above, nested parallelism should be
enabled.
Default: 1
KMP_HOT_TEAMS_MODE
Specifies the run-time behavior when the number of threads in a hot team is reduced.
Possible values:
*
0: Extra threads are freed and put into a common pool of threads.
*
1: Extra threads are kept in the team in reserve, for faster reuse in subsequent parallel regions.
Default: 0
KMP_INHERIT_FP_CONTROL
Enables (true) or disables (false) the copying of the floating-point control settings of the master thread to the floating-point control settings of the OpenMP* worker threads at the start of each parallel region.
Default:true
KMP_LIBRARY
Selects the OpenMP* run-time library execution mode. The values for this variable are serial, turnaround, or throughput.
Default:throughput
KMP_MONITOR_STACKSIZE
Sets the number of bytes to allocate for the monitor thread, which is used for book-keeping during program execution.
Use the optional suffixes to specify byte
units: B (bytes), K (Kilobytes), M (Megabytes), G (Gigabytes), or T (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be K (Kilobytes).
Default: max (32k, system minimum
thread stack size)
KMP_PLACE_THREADS
This environment variable only applies to Intel(R) Many Integrated Core Architecture (Intel(R) MIC Architecture).
Specifies the number of cores, with optional offset value
and number of threads per core, to use with an OpenMP* application, as an alternative to writing explicit affinity settings or a process affinity mask.

value = ( int [ "C" | "T" ] [ delim ] | delim ) [ int [ "T" ] [ delim ] ] [ int [ "O" ] ]; delim = "," | "x";

"C" indicates cores,
"T" indicates threads, "O" indicates an offset.

NOTE: Specify either cores or threads.

Default: If omitted, the default value is the
available number of cores (threads).
Examples:
*
5C,3T,1O: Use 5 cores with offset 1, 3 threads per core.
*
5,3,1: Same as above.
*
24: Use first 24 cores, all available threads per core.
*
2T: Use all cores, 2 threads per core.
*
,2: Same as above.
*
3x2: Use 3 cores, 2 threads per core
*
4C12O: Use 4 cores with offset 12, all available threads per core.
KMP_SETTINGS
Enables (true) or disables (false) the printing of OpenMP* run-time library environment variables during program execution. Two lists of variables are printed: user-defined environment variables settings and effective values of variables used by OpenMP* run-time library.
Default:false
KMP_STACKSIZE
Sets the number of bytes to allocate for each OpenMP* thread to use as its private stack.
Recommended size is 16m.
Use the optional suffixes to specify byte
units: B (bytes), K (Kilobytes), M (Megabytes), G (Gigabytes), or T (Terabytes) to specify the units. If you specify a value without a suffix, the byte unit is assumed to be K (Kilobytes).
This variable does not affect the native
operating system threads created by the user program nor the thread executing the sequential part of an OpenMP* program or parallel programs created using the option Qparallel (Windows) or qparallel (Linux and OS X).
Default (IA-32 architecture): 2m
Default (Intel(R) 64 architecture):
4m
Default (Intel(R) MIC
architecture):4M (on supported OSes)
KMP_VERSION
Enables (true) or disables (false) the printing of OpenMP* run-time library version information during program execution.
Default:false
KMP_WARNINGS
Enables (true) or disables (false) displaying warnings from the OpenMP* run-time library during program execution.
Default:true
Intel(R) Many Integrated Core
(Intel(R) MIC) Environment Variables
MIC_ENV_PREFIX
Controls environment variables passed to the target.
By default, all environment variables set on the host are
passed to the target. Setting MIC_ENV_PREFIX passes only environment variables that have a prefix of the value of this variable. For example, setting MIC_ENV_PREFIX=ABC passes only environment variables that have a prefix of ABC.

NOTE: Because the MIC_LD_LIBRARY_PATH variable is not stripped and passed to the target, you cannot use MIC_ENV_PREFIX= MIC to change the LD_LIBRARY_PATH on the target.

To change LD_LIBRARY_PATH on the target:

1)
Set MIC_ENV_PREFIX to any prefix other than MIC.
2)
Create an additional pre-fixed environment variable on the host set to the desired value for LD_LIBRARY_PATH for the target.

For example, setting these two environment variables on the host sets LD_LIBRARY_PATH on the target to /tmp/mylibs.

MIC_ENV_PREFIX=ABC ABC_LD_LIBRARY_PATH=/tmp/mylibs

MIC_LD_LIBRARY_PATH
Specifies the location on the host for target-specific shared objects that may be loaded to the target. The value is not passed to the target. See MIC_ENV_PREFIX for special handling of the value on the target.
LD_LIBRARY_PATH specifies the location on
the host for host-specific shared objects.
MIC_PROXY_IO
Enables (1) or disables (0) the proxy of stderr and stdout, and specifies whether the process wants I/O proxy support between the host and target.
Default:1
Example:MIC_PROXY_IO=0
MIC_SEP_MONITOR
Enables (1) or disables (0) SEP at offload regions.
Default:0
Example:MIC_SEP_MONITOR=1
MIC_STACKSIZE
Specifies the stack size of the main thread for the offload. This value is typically much larger than the stack size for individual threads. It corresponds to what you would set with ulimit -s (BASH shell) or limit stacksize (C shell) if you were running natively on either the target or the host.
Set this variable to
integerB|K|M|G|T, where:
*
B = bytes
*
K = kilobytes
*
M = megabytes
*
G = gigabytes
*
T = terabytes
Default:
12M
Example:MIC_STACKSIZE=16M
MIC_USE_2MB_BUFFERS
Use 2M pages for (size > MIC_USE_2MB_BUFFERS). Variables with the ALLOCATABLE or POINTER attribute whose runtime length exceeds the value of this environment variable are allocated in large pages.
Set this variable to
integerB|K|M|G|T, where:
*
B = Bytes
*
K = Kilobytes
*
M = Megabytes
*
G = Gigabytes
*
T = Terabytes
Example:MIC_USE_2MB_BUFFERS=64K
OFFLOAD_DEVICES
Restricts the offload process to use only the coprocessors specified as the value of the variable.
Set this variable to a comma-separated list of target device
numbers in the range 0 to (number_of_devices_in_the_system -1), where 0 is the first coprocessor in the system, and (number_of_devices_in_the_system -1) is the last coprocessor in the system.
Coprocessors available for offloading are numbered
logically. The function OFFLOAD_NUMBER_OF_DEVICES returns the number of available coprocessors. Coprocessor indices that you use in the target specifier of the offload directives are in the range 0 to number_of_devices_in_the_system-1.
Default: The offload process uses
all devices.
Example:OFFLOAD_DEVICES = 1,2
On a system with more than two coprocessors installed, this
setting enables the application to use only coprocessors 1 and 2. Offloads to coprocessors 0 or 1 are performed on the second and third physical coprocessors. Offloads to target numbers higher than 1 wrap around, and all offloads remain within coprocessors 0 and 1. The function OFFLOAD_NUMBER_OF_DEVICES, executed on a coprocessor, returns 0 or 1 when the offload is running on the first or second coprocessor.
Setting this variable to an empty value on Linux
(export OFFLOAD_DEVICES= ) or the value none on Windows (set OFFLOAD_DEVICES=none) impacts the execution of offloaded code within your program as follows:
*
When you use optional offloading, the code executes on the host CPU.
*
When you use mandatory offloading, the program terminates with an offload error, reporting that a device is not available, when it reaches a point in the execution where the coprocessor requires initialization for offloading.
You can specify optional and mandatory offloading using the
optional and mandatory clauses in either of the following:
*
The compiler option qoffload (Linux) or Qoffload (Windows)
*
The OFFLOAD directive
OFFLOAD_INIT
Specifies a hint to the offload runtime indicating when to initialize targets.
Possible values:
*
on_start: All available coprocessors are initialized before entering the main program.
*
on_offload: The target is initialized immediately before the first offload to it. Initialization is done only on the target that handles the offload.
*
on_offload_all: All available targets are initialized immediately before the first offload in an application.
Default:on_offload_all
Example:OFFLOAD_INIT=on_start
OFFLOAD_REPORT
Controls printing offload execution time, in seconds, and the amount of data transferred, in bytes. This environment variable is equivalent to using the __Offload_report API.
Possible values:
*
1: Prints the offload computation time, in seconds.
*
2: In addition to the information produced at value 1, adds the amount of data transferred between the CPU and the target, in bytes.
*
3: In addition to the information produced at value 2, gives additional details on offload activity, including device initialization, and individual variable transfers.
Default: None
Example:OFFLOAD_REPORT=1
See also
_Offload_report.
Profile Guided Optimization
(PGO_) Environment Variables
INTEL_PROF_DUMP_CUMULATIVE
When using interval profile dumping (initiated by INTEL_PROF_DUMP_INTERVAL or the function _PGOPTI_Set_Interval_Prof_Dump) during the execution of an instrumented user application, allows creation of a single information instead of multiple instrumented user application creates a new
Setting this environment variable is
useful for applications that do not terminate or those that terminate abnormally (bypass the normal exit code).
INTEL_PROF_DUMP_INTERVAL
Initiates interval profile dumping in an instrumented user application. This environment variable may be used to initiate Interval Profile Dumping in an instrumented application.
INTEL_PROF_DYN_PREFIX
Specifies the prefix to be used for the other files dumped by other PGO runs. Executing the instrumented application generates a .dyn filename as follows: <prefix>_<timestamp>_<pid>.dyn, where <prefix> is the identifier that you have specified.

NOTE: The value specified in this environment variable must not contain < > : " /  | ? * characters. The default naming scheme is used if an invalid prefix is specified.

PROF_DIR
Specifies the directory where profiling files (files with extensions

is to store the the file containing the first executed instrumented routine in the binary compiled with [Q]prof-gen option.

This variable applies to all three phases of the profiling
process:
*
Instrumentation compilation and linking
*
Instrumented execution
*
Feedback compilation
PROF_DPI
Name for the
Default:pgopti.dpi
PROF_DUMP_INTERVAL
Deprecated; use INTEL_PROF_DUMP_INTERVAL instead.
PROF_NO_CLOBBER
Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges data from all dynamic information files and creates a new pgopti.dpi file if the pgopti.dpi file.
When this variable is set, the compiler
does not overwrite the existing pgopti.dpi file. Instead, the compiler issues a warning. You must remove the pgopti.dpi file if you want to use additional dynamic information files.

 

TECHNICAL SUPPORT

The Intel(R) Compiler product web site offers timely and comprehensive product information, including product features, white papers, and technical articles.

For the latest information, visit http://www.intel.com/software/products/.

For support information, see the Release Notes. For general support information, visit http://www.intel.com/software/products/support/.

For licensing and registration information, visit https://registrationcenter.intel.com/.  

SEE ALSO

ifort(1), ld(1)

The Intel(R) Fortran Compiler Documentation has additional reference material on features of the Intel(R) Fortran Compiler.  

Legal Information

No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document.

Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade.

This document contains information on products, services and/or processes in development. All information provided here is subject to change without notice. Contact your Intel representative to obtain the latest forecast, schedule, specifications and roadmaps.

The products and services described may contain defects or errors which may cause deviations from published specifications.

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. Go to: Learn About Intel(R) Processor Numbers

Intel[aq]s compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804

Intel, Intel Atom, Intel Core, Intel Cilk, Intel VTune, MMX, Pentium, Xeon, and Intel Xeon Phi are trademarks of Intel Corporation in the U.S. and/or other countries.

* Other names and brands may be claimed as the property of others.

(C) 2015, Intel Corporation.

Portions Copyright (C) 2001, Hewlett-Packard Development Company, L.P.


 

Index

SYNOPSIS
DESCRIPTION - ifort
Options that Improve Run-Time Performance
Configuration and Indirect Files
Feature Requirements
OPTIONS
PREDEFINED SYMBOLS
Supported Environment Variables
Compiler Compile-Time Environment
Compiler Run-Time Environment
TECHNICAL SUPPORT
SEE ALSO
Legal Information

This document was created by man2html, using the manual pages.
Time: 16:15:19 GMT, July 18, 2016