You can override some options specified on the command line by using the
OPTIONS statement in your Fortran source program.
An OPTIONS statement affects only the program unit in which
the statement occurs. For more information, see the Intel(R) Fortran Language Reference.
Most language features are available on all supported systems.
However, some language features are only
available on certain processors or a certain operating system. Such language features are labeled within parentheses as follows:
If a labeled feature is only available on one processor or one operating system, you will see the word [dq]only[dq] within the label.
If no label appears, the language feature is available on all supported systems.
passes [dq]-O3 -i8 -r8 myprog.f90 -I/bld/inc -I/bld/headers[dq] to the compiler.
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 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.
- -1
-
Tells the compiler to execute at least one iteration of DO loops (same as the
-onetrip
option).
This option has the same effect as
-f66.
- -66
-
Enforces FORTRAN 66 semantics (same as the
-f66
option).
- -72
-
Specifies that the statement field of each fixed-form source line ends at column 72.
This is the default.
- -80
-
Specifies that the statement field of each fixed-form source line ends at column 80.
- -132
-
Specifies that the statement field of each fixed-form source line ends at column 132
(same as the
-extend-source
option).
- -align [keyword]
-
Tells the compiler how to align certain data items. The following are
-align
options:
-
- *
-
-align all
-
Tells the compiler to add padding bytes whenever possible to obtain the natural
alignment of data items in common blocks, derived types, and record structures.
Specifies
-align
nocommons,
-align
dcommons,
-align
records,
-align
nosequence.
This is the same as specifying
-align
with no keyword.
- *
-
-align commons
-
Aligns all common block entities on natural boundaries up to 4 bytes, by adding padding bytes as needed. The default is
-align
nocommons,
which adds no padding to common blocks.
- *
-
-align dcommons
-
Aligns all common block entities on natural boundaries up to 8 bytes, by adding padding bytes as needed. If you specify any
-std
option or the
-stand f90
or
-stand f95
option, this option is ignored.
The default is
-align
nodcommons,
which adds no padding to common blocks.
- *
-
-align none
-
Tells the compiler not to add padding bytes anywhere in
common blocks or structures. This is the same as specifying
-noalign.
The default is to add no padding to common blocks but to add padding
to structures.
- *
-
-align norecords
-
Aligns components of derived types and fields within record structures on arbitrary
byte boundaries with no padding. The default is
-align
records.
- *
-
-align
rec<n>byte
-
Aligns fields of records and components of derived types
on the smaller of the size boundary specified
or the boundary that will naturally align them. <n> can be 1, 2, 4, 8, or 16.
- *
-
-align sequence
-
Aligns components of a derived type declared with the SEQUENCE statement (sequenced
components) according to the alignment rules that are currently in use.
The default
alignment rules are to align unsequenced components on natural boundaries.
The default is
-align
nosequence,
which requests that sequenced components be packed regardless of any other alignment rules.
If you specify any
-std
option or the
-stand f90
or
-stand f95
option, this option is ignored.
-
The defaults for
-align
are
nocommons,
nodcommons,
records,
and
nosequence.
- -allow nofpp_comments
-
Tells the compiler to disallow Fortran-style end-of-line comments on preprocessor lines. This means comment indicators have no special meaning.
-
This option can be useful when you want to have a Fortran directive as a define value.
The default is
-allow
fpp_comments,
which tells the compiler to recognize Fortran-style end-of-line comments on
preprocessor lines.
- -arch <keyword> (i32 and i64em)
-
Determines the version of the architecture for which the compiler generates instructions. The following are
-arch
options:
-
- *
-
-arch pn1
-
Optimizes for the Intel(R) Pentium(R) processor.
- *
-
-arch pn2
-
Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.
- *
-
-arch pn3
-
Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.
This is the same as specifying the
-arch pn2
option.
- *
-
-arch pn4
-
Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default.
- *
-
-arch SSE
-
Optimizes for Intel Pentium 4 processors with Streaming SIMD Extensions (SSE).
- *
-
-arch SSE2
-
Optimizes for Intel Pentium 4 processors with Streaming SIMD Extensions 2 (SSE2).
-
The only <keyword>s valid on systems using IA-32 architecture are
pn1,
pn2,
pn3,
and
pn4.
- -assume <keyword>
-
Tells the compiler to make certain assumptions.
The following are
-assume
options:
-
- *
-
-assume bscc
-
Tells the compiler to treat the backslash character (\) as a C-style control (escape) character
syntax in character literals. The default is
-assume
nobscc,
which tells the compiler to treat the backslash character as a normal character instead of a
control character in character literals.
- *
-
-assume buffered_io
-
Tells the compiler to accumulate records in a buffer. This sets the default for opening sequential output files to BUFFERED=[aq]YES[aq], which also occurs if the FORT_BUFFERED run-time environment variable is specified. The default is
-assume
nobuffered_io,
which means that data will be immediately written to disk.
- *
-
-assume byterecl
-
Specifies that the units for the OPEN statement RECL specifier (record length) value are in bytes for unformatted data files, not longwords (four-byte
units). For formatted files, the RECL unit is always in bytes. The default is
-assume
nobyterecl.
-
INQUIRE returns RECL in bytes if the unit is not open. INQUIRE returns RECL
in longwords if the file is open for unformatted data (and
-assume
byterecl
is not specified); otherwise, it returns RECL in bytes.
- *
-
-assume cc_omp
-
Enables conditional compilation as defined
by the OpenMP* Fortran API. That is, when
!$space
appears in free-form source or
c$spaces
appears in column 1 of fixed-form source,
the rest of the line is accepted as a Fortran line. If
-openmp
is specified, the default is
-assume
cc_omp;
otherwise, the default is
-assume
nocc_omp.
- *
-
-assume dummy_aliases
-
Tells the compiler that dummy (formal) arguments to procedures share memory locations with other dummy arguments (aliases) or with variables shared through use association, host association, or common block use. These program semantics slow performance and do
not strictly obey the Fortran 95/90 Standards. The default is
-assume
nodummy_aliases.
- *
-
-assume minus0
-
Tells the compiler to use Fortran 95 standard semantics for the treatment of the IEEE* floating value -0.0 in the SIGN intrinsic, which distinguishes the difference between -0.0 and +0.0, and to write a value of -0.0 with a negative sign on formatted output.
-
The default is
-assume
nominus0,
which tells the compiler to use Fortran 90/77 standard semantics
in the SIGN intrinsic to treat -0.0 and +0.0 as 0.0, and to write a value of 0.0 with no
sign on formatted output.
- *
-
-assume none
-
Disables all the
-assume
options.
- *
-
-assume old_boz
-
Tells the compiler that the binary, octal, and hexadecimal constant arguments in the
intrinsic functions INT, REAL, DBLE, and CMPLX should be treated as signed integer constants. The default is
-assume
noold_boz,
which tells the compiler that they should be treated as bit strings that represent
a value of the data type of the intrinsic, that is, the bits are not converted.
- *
-
-assume noold_unit_star
-
Tells the compiler that READs or WRITEs to UNIT=* go to whatever file UNIT=5 or 6 is connected. The default is
-assume
old_unit_star,
which tells the compiler that READs or WRITEs to UNIT=* go to stdin or
stdout, respectively, even if UNIT=5 or 6 has been connected to another file.
- *
-
-assume noold_xor
-
Prevents the compiler from defining .XOR. as an intrinsic operator. This lets you specify .XOR. as a user-defined operator. The default is
-assume
old_xor,
which tells the compiler to define .XOR. as an intrinsic operator.
- *
-
-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).
The default is
-assume
noprotect_parens,
which allows the
optimizer to reorder REAL and COMPLEX expressions without regard for parentheses if it
produces faster executing code.
- *
-
-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, which may cause extra overhead at run time.
The default is
-assume
norealloc_lhs,
where 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.
- *
-
-assume nosource_include
-
Tells the compiler to search the default directory for module files specified by a USE statement or source files specified by an INCLUDE statement. The default is
-assume
source_include,
which tells the compiler to search the directory the source file is in
for any INCLUDE files or modules.
- *
-
-assume 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 default is
-assume
nostd_mod_proc_name,
which allows the names of module procedures to conflict with user external symbol names. For example, procedure proc in module m would be named m_mp_proc, which could conflict with a user-defined external name m_mp_proc.
- *
-
-assume nounderscore
-
Tells the compiler not to append an underscore character to external user-defined names:
the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected.
The default is
-assume
underscore.
- *
-
-assume 2underscores
-
Tells the compiler to append two underscore characters to external user-defined names that contain an embedded underscore:
the main program name, named common blocks, BLOCK DATA blocks, global data names in MODULEs, and names implicitly or explicitly declared EXTERNAL. The name of a blank (unnamed) common block remains _BLNK__, and Fortran intrinsic names are not affected.
The default is
-assume
no2underscores.
-
This option does not affect external names that do not contain an embedded underscore.
By default, the compiler only appends one underscore to those names.
- *
-
-assume writeable-strings
-
Tells the compiler to put character constants into non-read-only memory. The default is
-assume
nowriteable-strings.
- -auto
-
Causes all local, non-SAVEd variables to be allocated on the run-time stack
(same as -automatic or -nosave). The default is
-auto-scalar.
However, if you specify
-recursive
or
-openmp,
the default is
-automatic.
- -auto-scalar
-
Causes 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. This is the default. However, if you specify
-recursive
or
-openmp,
the default is
-automatic.
-
You cannot specify
-save,
-auto,
or
-automatic
with this option.
- -autodouble
-
Makes default real and complex variables 8 bytes long. REAL declarations are treated as
DOUBLE PRECISION (REAL(KIND=8)) and COMPLEX declarations are treated as DOUBLE COMPLEX (COMPLEX(KIND=8)). This option is the same as specifying
-real-size 64
or
-r8.
- -automatic
-
Causes all local, non-SAVEd variables to be allocated on the run-time stack (same
as
-auto
or -nosave). The default is
-auto-scalar.
However, if you specify
-recursive
or
-openmp,
the default is
-automatic.
- -ax<processor> (i32 and i64em)
-
Tells the compiler to generate multiple, processor-specific code
paths if there is a performance benefit. It also generates a generic IA-32 architecture code path.
<processor> is a value used to target specific processors or microarchitectures for the optimized code paths. The following are
-ax
options:
-
- *
-
-axS
-
Can generate specialized code paths using Intel(R) Streaming SIMD Extensions 4 (SSE4)
Vectorizing Compiler and Media Accelerators instructions for future Intel
processors that support the instruction set and it can optimize for the architecture.
- *
-
-axT
-
Can generate specialized code paths for SSSE3, SSE3, SSE2, and
SSE instructions for Intel processors, and it can optimize for the Intel(R) Core(TM)2 Duo processor family.
- *
-
-axP
-
Can generate specialized code paths for SSE3, SSE2, and SSE instructions
for Intel processors, and it can optimize for Intel processors based on Intel(R) Core(TM)
microarchitecture and Intel Netburst(R) microarchitecture.
- *
-
-axB
-
Can generate specialized code paths for SSE2 and SSE instructions for Intel processors, and it can optimize for Intel(R) Pentium(R) M processors. This is a deprecated option.
- *
-
-axN
-
Can generate specialized code paths for SSE2 and SSE instructions for
Intel processors, and it can optimize for Pentium(R) 4 processors and
Intel(R) Xeon(R) processors with SSE2.
- *
-
-axW
-
Can generate specialized code paths for SSE2 and SSE instructions
for Intel processors, and it can optimize for Intel Pentium(R) 4 processors and
Intel(R) Xeon(R) processors with SSE2.
- *
-
-axK
-
Can generate specialized code paths for SSE instructions for
Intel processors and it can optimize for Intel(R) Pentium(R) III and Intel(R)
Pentium(R) III Xeon(R) processors.
-
This option enables the vectorizer and tells the compiler to find opportunities
to generate separate versions of functions that take advantage of features of
the specified Intel(R) processor.
-
On Linux* systems using Intel(R) 64 architecture, B, N, and K are not
valid processor values.
-
On Mac OS* X systems using IA-32 architecture, S, T, and P are the only valid processor
values. On Mac OS X systems using Intel(R) 64 architecture, S and T are the only valid
processor values.
-
You can use more than one of the processor values by combining them. For example, you
can specify
-axTP
to generate code for
Intel(R) Core(TM)2 Duo processors and Intel(R) Pentium(R) 4 processors with SSE3.
-
If you specify both the
-ax
and
-x
options, the generic code will only execute on
processors compatible with the processor type specified by the
-x
option.
-
By default, no processor specific code is generated, except as controlled by option
-x.
- -B<dir>
-
Specifies a directory that can be used to find include files, libraries,
and executables. The compiler uses <dir> as a prefix.
-
For include files, the <dir> is converted to -I/<dir>/include. This command is added to the front of the includes passed to the preprocessor.
-
For libraries, the <dir> is converted to -L/<dir>. This command is added to the front
of the standard -L inclusions before system libraries are added.
-
For executables, if <dir> contains the name of a tool, such as ld or as, the compiler
will use it instead of those found in the default directories.
-
The compiler looks for include files in <dir>/include while library files are looked
for in <dir>.
- -Bdynamic (L*X only)
-
Enables dynamic linking of libraries at run time. Smaller executables are created than with
static linking.
- -Bstatic (L*X only)
-
Enables static linking of a user-created library.
- -c
-
Prevents linking. It causes the compiler to compile to an object (.o) file only.
- -C
-
Enables all checks on run-time conditions (same as the
-check all
option).
- -CB
-
Performs run-time checks on whether array subscript and substring references are within declared
bounds (same as the
-check bounds
option).
- -ccdefault <keyword>
-
Specifies the type of carriage control used when a file is displayed at a terminal
screen (units 6 and *). The following are
-ccdefault
options:
-
- *
-
-ccdefault default
-
Specifies that the compiler is to use the default
carriage-control setting. This is the default.
-
The default setting can be affected by the
-vms
option: if [dq]-vms -ccdefault default[dq]
is specified, carriage control
defaults to FORTRAN if the file is formatted, and the unit
is connected to a terminal; if [dq]-novms -ccdefault default[dq]
is specified, carriage control defaults to LIST.
- *
-
-ccdefault fortran
-
Specifies normal Fortran interpretation of the first character.
- *
-
-ccdefault list
-
Specifies one line feed between records.
- *
-
-ccdefault none
-
Specifies no carriage control processing.
- -check [keyword]
-
Checks for certain conditions at run time. The following are
-check
options:
-
- *
-
-check all
-
Enables all
-check
options. This is the same as specifying
-check
with no keyword.
- *
-
-check arg_temp_created
-
Generates code to check if actual arguments are copied into
temporary storage before routine calls. If a copy is made at
run time, an informative message is displayed. The default is
-check
noarg_temp_created.
- *
-
-check bounds
-
Generates code to perform compile-time and run-time checks on array subscript and character substring expressions. The default is
-check
nobounds.
- *
-
-check format
-
Issues the run-time FORVARMIS fatal error when the
data type of an item being formatted for output does not match the
format descriptor being used (for example, a REAL*4 item formatted
with an I edit descriptor). If
-vms
is specified, the default is
-check
format;
otherwise, the default is
-check
noformat.
-
With
-check
noformat,
the data item is formatted using the specified
descriptor unless the length of the item cannot accommodate the
descriptor (for example, it is still an error to pass an INTEGER*2 item
to an E edit descriptor).
- *
-
-check none
-
Disables all
-check
options. This is the default.
This is the same as specifying
-nocheck.
- *
-
-check output_conversion
-
Issues the run-time OUTCONERR continuable error message when
a data item is too large to fit in a
designated format descriptor field. The field is filled with
asterisks (*) and execution continues. If
-vms
is specified, the default is
-check
output_conversion;
otherwise, the default is
-check
nooutput_conversion.
- *
-
-check pointers
-
Enables run-time checking for disassociated or uninitialized Fortran pointers, unallocated
allocatable objects, and integer pointers that are uninitialized. The default is
-check
nopointers.
- *
-
-check uninit
-
Generates code to check for uninitialized variables (same as the
-CU
option).
If a variable is read before 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.
The default is
-check
nouninit.
-
To get more detailed location information about where the error occurred,
use
-traceback.
- -cm
-
Suppresses all warning messages about questionable programming practices (same as the
-warn nousage
option).
- -common-args
-
Tells the compiler that dummy (formal) arguments
to procedures share memory locations with other dummy arguments or with variables shared
through use association, host association, or common block use.
This is the same as specifying
-assume
dummy_aliases.
- -complex-limited-range
-
Enables the use of basic algebraic expansions of some arithmetic
operations involving data of type COMPLEX. This can cause some performance improvements in
programs that use a lot of COMPLEX arithmetic, but values at the extremes of the exponent range
may not compute correctly. The default is
-no-complex-limited-range,
which disables this option.
- -convert <keyword>
-
Specifies the format for unformatted files containing numeric data. The
following are
-convert
options:
-
- *
-
-convert big_endian
-
Specifies that the format will be big endian for INTEGER*1,
INTEGER*2, INTEGER*4, or INTEGER*8, and big endian IEEE floating-point for REAL*4,
REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32.
- *
-
-convert cray
-
Specifies that the format will be big endian for INTEGER*1,
INTEGER*2, INTEGER*4, or INTEGER*8, and CRAY* floating-point for REAL*8 or COMPLEX*16.
- *
-
-convert fdx
-
Specifies that the format will be little endian for INTEGER*1, INTEGER*2,
INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8,
D_floating for REAL*8 or COMPLEX*16, and X_floating for
REAL*16 or COMPLEX*32.
- *
-
-convert fgx
-
Specifies that the format will be little endian for INTEGER*1, INTEGER*2,
INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8,
G_floating for REAL*8 or COMPLEX*16, and X_floating for
REAL*16 or COMPLEX*32.
- *
-
-convert ibm
-
Specifies that the format will be big endian for INTEGER*1, INTEGER*2,
or INTEGER*4, and IBM* System\370 floating-point format for REAL*4 or COMPLEX*8 (IBM short 4)
and REAL*8 or COMPLEX*16 (IBM long 8).
- *
-
-convert little_endian
-
Specifies that the format will be little endian for INTEGER*1,
INTEGER*2, INTEGER*4, or INTEGER*8, and little endian IEEE floating-point for REAL*4,
REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32.
- *
-
-convert native
-
Specifies that unformatted data should not be converted. This is the default.
- *
-
-convert vaxd
-
Specifies that the format will be little endian for INTEGER*1, INTEGER*2,
INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8,
D_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32.
- *
-
-convert vaxg
-
Specifies that the format will be little endian for INTEGER*1, INTEGER*2,
INTEGER*4, or INTEGER*8, and VAX processor floating-point format F_floating for REAL*4 or COMPLEX*8,
G_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32.
- -cpp
-
Runs the Fortran preprocessor on source files prior to compilation
(same as the
-fpp
option).
- -CU
-
Generates code to check for uninitialized variables
(same as the
-check uninit
option).
If a variable is read before written, a run-time error routine will be called.
- -cxxlib[=<dir>]
-
Tells the compiler to link using the C++ run-time libraries provided by gcc.
<dir> is an optional top-level location for the gcc binaries and libraries.
-
The default is
-no-cxxlib,
which tells the compiler to use the default run-time libraries and not link to any
additional C++ run-time libraries. This is the same as specifying
-no-cpprt.
- -cxxlib-nostd
-
Prevents the compiler from linking with the standard C++ library. It is only useful for mixed-language applications.
- -D<name>[=<value>]
-
Specifies <name> as a definition (symbol) to use with conditional
compilation directives or the Fortran preprocessor (-fpp).
<value> can be an integer or it can be a character string delimited
by double quotes; for example,
-Dname=[dq]string[dq].
If <value> is not specified, <name> is defined as [dq]1[dq].
- -DD
-
Compiles debug statements (indicated by D in column 1); this is the same as specifying
-d-lines.
- -d-lines
-
Compiles debug statements (indicated by D in column 1); this is the same as specifying
-DD.
The default is
-nod-lines.
- -debug [keyword]
-
Specifies settings for general or enhanced debugging. The following are
-debug
options:
-
- *
-
-debug all
-
Generates complete debugging information. This is the default if no keyword is specified.
- *
-
-debug full
-
Generates complete debugging information (same as
-debug
all).
- *
-
-debug minimal
-
Generates line number information for debugging.
- *
-
-debug none
-
Disables generation of debugging information. This is the default if no
-debug
option is specified.
- *
-
-debug inline-debug-info
-
Produces enhanced debug information for inlined code.
It provides more information to debuggers for function call traceback.
- *
-
-debug semantic-stepping
-
Produces enhanced debug information useful for breakpoints and stepping.
It tells the debugger to stop only at machine instructions that achieve the final
effect of a source statement. For example, in the case of an assignment statement,
this might be a store instruction that assigns a value to a program variable; for
a function call, it might be the machine instruction that executes the call. Other
instructions generated for those source statements are not displayed during stepping.
- *
-
-debug variable-locations
-
Produces enhanced debug information useful in finding scalar local variables.
It uses a feature of the Dwarf object module known as [dq]location lists[dq]. This feature
allows the run-time locations of local scalar variables to be specified more accurately;
that is, whether, at a given position in the code, a variable value is found in memory
or a machine register.
- *
-
-debug extended
-
Sets the debug options
semantic_stepping
and
variable-locations.
- -debug-parameters [keyword]
-
Tells the compiler to generate debug information for PARAMETERs used in a program. The following are
-debug-parameters
options:
-
- *
-
-debug-parameters none
-
Generates no debug information for any PARAMETERs used in the program. This is the default; it is the same as specifying
-nodebug-parameters.
- *
-
-debug-parameters used
-
Generates debug information for only PARAMETERs that have actually been referenced in the program. This is the same as specifying
-debug-parameters
with no keyword.
- *
-
-debug-parameters all
-
Generates debug information for all PARAMETERs defined in the program.
-
Note that if a .mod file contains PARAMETERs, debug information is only generated for the PARAMETERs that have actually been referenced in the program, even if you specify
-debug-parameters
all.
- -diag-<type> <diag-list>
-
Controls the display of diagnostic information. You can specify one of the following values for <type>:
enable
- Enables a diagnostic message or a group of messages.
disable
- Disables a diagnostic message or a group of messages.
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).
-
You can specify one of the following values for <diag-list>:
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).
sv[<n>]
- Specifies diagnostic messages issued by the Static Verifier. <n> can be any of the following: 1, 2, 3.
warn
- Specifies diagnostic messages that have a [dq]warning[dq] severity level. For Static Verifier diagnostics, it affects all diagnostics except those that have an error severity level. This value affects all Static Verifier warnings, cautions, and remarks.
error
- Specifies diagnostic messages that have an [dq]error[dq] severity level.
remark
- Specifies diagnostic messages that are remarks or comments.
cpu-dispatch (i32 and i64em)
- Specifies the CPU dispatch remarks for diagnostic messages. These remarks are enabled by default.
id[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,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 compiler issues certain diagnostic messages by default.
-
-diag-enable vec
is the same as option
-vec-report.
-diag-disable vec
is the same as option
-vec-report0.
-diag-enable par
is the same as option
-par-report.
-diag-disable par
is the same as option
-par-report0.
- -diag-dump
-
Tells the compiler to print all enabled diagnostic messages and stop compilation.
The diagnostics are printed to stdout.
- -diag-enable sv-include
-
Tells the Static Verifier to analyze include files as well as source files when issuing diagnostic messages.
-
To use this option, you must also specify
-diag-enable sv
to enable the Static Verifier diagnostics.
- -diag-file[=<file>]
-
Causes the results of diagnostic analysis to be output to <file>. The file is placed in the current working directory.
-
If <file> is specified, the name of the file is file.diag. The <file> can include a file extension; for example, if <file.ext> is specified, the name of the file is <file.ext>.
-
If <file> 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 the source file name provided in the command line.
-
If you specify this option and you also specify
-diag-file-append,
the last option specified on the command line takes precedence.
- -diag-file-append[=<file>]
-
Causes the results of diagnostic analysis to be appended to <file>. <file> can include a path.
-
If you do not specify a path, the driver will look for <file> in the current working directory.
-
If <file> 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.
-
If you specify this option and you also specify
-diag-file,
the last option specified on the command line takes precedence.
- -double-size <size>
-
Defines the default KIND for DOUBLE PRECISION and DOUBLE COMPLEX declarations,
constants, functions, and
intrinsics. <size> can be 64 (KIND=8) or 128 (KIND=16). The default
is -double-size 64.
- -dryrun
-
Tells the driver that tool commands should be shown but not executed.
See also
-v.
- -dumpmachine
-
Displays the target machine and operating system configuration.
- -dynamic-linker<file> (L*X only)
-
Specifies a dynamic linker (<file>) other than the default.
- -dynamiclib (M*X only)
-
Invokes the libtool command to generate dynamic libraries.
When passed this option, GCC on Mac OS X uses the libtool command
to produce a dynamic library instead of an executable when linking.
-
To build static libraries, you should
use [dq]libtool -static <objects>[dq].
- -dyncom "common1,common2,..."
-
Enables dynamic allocation of the specified COMMON blocks at run time. The quotes must be present.
- -E
-
Causes the Fortran preprocessor to send output to stdout.
- -e03
-
Causes the compiler to issue errors instead of warnings for nonstandard Fortran
(same as specifying the
-warn stderrors
option). This is the default.
- -e90
-
Causes the compiler to issue errors instead of warnings for nonstandard Fortran 90
(same as specifying the
-warn stderrors -std90
options).
No such errors or warnings are issued by default.
- -e95
-
Causes the compiler to issue errors instead of warnings for nonstandard Fortran
(same as specifying the
-warn stderrors -std95
option).
No such errors or warnings are issued by default.
- -EP
-
Causes the Fortran preprocessor to send output to stdout, omitting #line directives.
- -error-limit <n>
-
Specifies the maximum number of error-level or fatal-level compiler errors
allowed for a file specified on the command line. If you specify
-noerror-limit,
there is no limit
to the number of errors that are allowed. The default is
-error-limit 30
(a maximum of 30 error-level and fatal-level messages before the compiler stops the compilation).
- -extend-source [size]
-
Specifies the column number to use to end the statement field in fixed-form source files. [size] can be 72, 80, or 132. The default behavior
is
-noextend-source,
which implies column 72. If you do not specify size,
it is the same as specifying
-extend-source
132.
- -f66
-
Tells the compiler to apply FORTRAN 66 semantics:
the execution of at least
one iteration of DO loops, different EXTERNAL statement
syntax and semantics, and different behavior of the BLANK=
and STATUS= specifiers on the OPEN statement.
This is the same as specifying the
-66
option. By default, the compiler applies Fortran 95 semantics.
- -f77rtl
-
Tells the compiler to use the run-time
behavior of Fortran 77 instead of Intel(R) Fortran.
This affects some INQUIRE specifiers when the unit is not
connected to a file, PAD= defaults to [aq]NO[aq] for formatted input,
NAMELIST input format is different, and NAMELIST
and list-directed input of character strings must be delimited
by apostrophes or quotes. The default is
-nof77rtl.
- -falign-functions[=<n>] (i32 and i64em)
-
Tells the compiler to align functions on an optimal byte boundary. <n> is the byte boundary. Possible values are 2 or 16. The default is
-fno-align-functions,
which aligns functions on 2-byte boundaries. This is the same as specifying
-falign-functions=2.
If you do not specify <n>, the compiler aligns the start of functions on 16-byte boundaries.
- -fast
-
Maximizes speed across the entire program.
On systems using IA-64 architecture, this option sets options
-ipo,
-O3,
and
-static.
On systems using IA-32 architecture and systems using Intel(R) 64 architecture, this option sets options
-ipo,
-O3,
-no-prec-div,
-static,
and
-xP.
On Mac OS X systems, this option sets option
-mdynamic-no-pic.
-
Note that programs compiled with the
-xP
option will detect non-compatible processors and generate an error message during execution.
- -fcode-asm
-
Produces an assembly listing with machine code annotations.
To use this option, you must also specify
-S.
- -fexceptions
-
Enables C++ exception handling table generation, preventing Fortran routines in
mixed-language applications from interfering with exception handling between C++ routines. The default is
-fno-exceptions,
which disables C++ exception handling table generation, resulting in smaller code. When this option is used, any use of C++ exception handling constructs (such as try blocks and throw statements) when a Fortran routine is in the call chain will produce an error.
- -FI
-
Specifies source files are in fixed format (same as the
-fixed
option).
- -finline-limit=<n>
-
Lets you specify the maximum size of a function to be inlined. n must be
an integer greater than or equal to zero. It is the maximum number of lines the function can have to be considered for inlining.
-
The compiler inlines smaller functions, but this option
lets you inline large functions. For example, to indicate a large function, you could specify 100 or 1000 for n.
- -finstrument-functions
-
Tells the compiler that routine entry and exit points are instrumented. It also disables routine inlining. This option may increase execution time. Inlining is not disabled if you specify
-fno-instrument-functions,
the default.
- -fixed
-
Specifies source files are in fixed format. By default, source file format
is determined by the file suffix.
- -fkeep-static-consts
-
Tells the compiler to preserve allocation of variables that are not referenced in
the source. The default is
-fno-keep-static-consts,
which tells the compiler to discard variables if they are not referenced in a routine
unless optimizations are disabled by option
-O0.
- -fltconsistency
-
Enables improved floating-point consistency. Floating-point operations are not reordered
and the result of each floating-point operation is stored in the target variable
rather than being kept in the floating-point processor for use in a subsequent calculation.
This is the same as specifying
-mp
or
-mieee-fp.
-
The default,
-nofltconsistency,
provides better accuracy and run-time performance
at the expense of less consistent floating-point results.
- -fmath-errno
-
Tells the compiler to assume that the program tests errno after calls to
math library functions. This restricts optimization because it causes the
compiler to treat most math functions as having side effects.
-
The default,
-fno-math-errno,
tells the compiler to assume that the program does not test errno after
calls to math library functions. This frequently allows the compiler to
generate faster code. Floating-point code that relies on IEEE exceptions
instead of errno to detect errors can safely use this option to improve performance.
- -fminshared
-
Specifies that a compilation unit is a component of a main program and will not be linked as part of a shareable object.
- -fno-alias
-
Specifies that aliasing should not be assumed in the program. The default is
-falias.
- -fno-fnalias
-
Specifies that aliasing should not be assumed within functions, but should be assumed across calls.
The default is
-ffnalias.
- -fno-inline-functions
-
Disables function inlining for single file compilation.
The default is
-finline-functions,
which tells the compiler to perform
inline function expansion for calls to functions defined within the current source file.
- -fno-omit-frame-pointer (i32 and i64em)
-
Disables use of EBP as a general purpose register so it can be used as a stack frame pointer. This is the same as specifying
-fp,
which is deprecated.
The default,
-fomit-frame-pointer,
enables EBP to be used as a general purpose register.
- -fnsplit (i64 only; L*X only)
-
Enables function splitting if -prof-use is also specified. Otherwise, the default is
-no-fnsplit,
which disables the splitting within a routine but leaves function grouping enabled.
- -fp (i32 and i64em)
-
Disables use of EBP as a general purpose register so it can be used as a stack frame pointer. By default, EBP is used as a general purpose register. This is a deprecated option, you should use
-fno-omit-frame-pointer.
- -fp-model <keyword>
-
Controls the semantics of floating-point calculations. The
following are
-fp-model
options:
-
- *
-
-fp-model precise
-
Enables value-safe optimizations on floating-point data and rounds intermediate results
to source-defined precision.
Disables optimizations that can change the result of floating-point calculations,
which is required for strict ANSI conformance. These semantics ensure the accuracy
of floating-point computations, but they may slow performance.
-
Floating-point exception semantics are disabled by default.
-
This option is equivalent to
-fp-model
source.
- *
-
-fp-model fast[=1|2]
-
Enables more aggressive optimizations when implementing floating-point
calculations. These optimizations increase speed, but may alter the accuracy of
floating-point computations.
-
Specifying
fast
is the same as specifying
fast=1.
fast=2
may produce faster and less accurate results.
-
Floating-point exception semantics are disabled by default and they cannot be enabled.
- *
-
-fp-model strict
-
Enables
precise
and
except.
This is the strictest floating-point model.
- *
-
-fp-model source
-
Enables value-safe optimizations on floating-point data and rounds intermediate results
to source-defined precision. This option is equivalent to
-fp-model
precise.
- *
-
-fp-model [no-]except
-
Determines whether floating-point exception semantics are used.
Floating-point exception semantics are enabled if
-fp-model except
is specified; they are disabled if
-fp-model no-except
is specified.
-
The default is
-fp-model
fast=1.
However, if you specify
-O0,
the default is
-fltconsistency.
-
The keywords can be considered in groups:
-
- *
-
Group A:
source,
precise,
fast,
strict
- *
-
Group B:
except
or
no-except
-
You can use more than one keyword. However, the following rules apply:
-
- *
-
You cannot specify
fast
and
except
together in the same compilation. You can specify
any other combination of group A and group B.
-
Since
fast
is the default, you must not specify
except
without a group A keyword.
- *
-
You should specify only one keyword from group A. If you try to specify
more than one keyword from group A, the last (rightmost) one takes effect.
- *
-
If you specify
except
more than once, the last (rightmost) one takes effect.
- -fp-port (i32 and i64em)
-
Tells the compiler to round floating-point results after floating-point operations.
This has some impact on speed. The default is
-no-fp-port,
which keeps results of floating-point operations in higher precision. This provides better performance but less consistent floating-point results.
- -fp-speculation<mode>
-
Tells the compiler to speculate on floating-point (FP) operations in
one of the following <mode>s:
fast
- Speculate on floating-point operations. This is the default.
safe
- Disables speculation if there is a possibility that the speculation
may cause a floating-point exception.
strict
- This is the same as specifying
off.
off
- Disables speculation of floating-point operations.
-
This option is the same as deprecated option
-IPF-fp-speculation,
but it is available on more processors.
- -fp-stack-check (i32 and i64em)
-
Generates extra code after every function call to ensure that the FP (floating-point) stack
is in the expected state.
By default, there is no checking. So when the FP stack overflows, a NaN value is put into FP calculations, and the
results of the program differ. Unfortunately, the overflow point can be far away from the point of the actual bug. The
-fp-stack-check
option places code that causes an access violation exception immediately after
an incorrect call occurs, thus making it easier to locate these issues. This option is the same as deprecated option
-fpstkchk.
- -fpconstant
-
Tells the compiler to extend the precision to double precision for single-precision constants
assigned to double-precision variables. The default is
-nofpconstant.
- -fpe<n>
-
Specifies floating-point exception handling for the main program at run-time.
You can specify one of the following values for <n>:
0
- Floating-point invalid, divide-by-zero, and overflow exceptions are enabled. If any
such exceptions occur, execution is aborted. Underflow results will be set to zero
unless you explicitly specify
-no-ftz.
On systems using IA-64 architecture, underflow behavior is equivalent to specifying option
-ftz.
On systems using IA-32 architecture or Intel(R) 64 architecture, underflow results from SSE instructions, as well
as x87 instructions, will be set to zero. By contrast, option -ftz only sets
SSE underflow results to zero.
To get more detailed location information about where the error occurred,
use
-traceback.
1
- All floating-point exceptions are disabled.
On systems using IA-64 architecture, underflow behavior is equivalent to specifying option
-ftz.
On systems using IA-32 architecture and systems using Intel(R) 64 architecture, 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.
This is the default; it provides full IEEE support. (Also see -ftz.)
- -fpic (L*X only)
-
Generates position-independent code. On systems using IA-32 architecture and systems using Intel(R) 64 architecture, this option must be used when building shared objects. This option can also be specified as
-fPIC.
The default is
-fno-pic.
- -fpp[n]
-
Runs the Fortran preprocessor on source files prior to compilation.
You can specify one of the following values for [n]:
0
- Tells the compiler not to run the preprocessor (equivalent to -nofpp).
1, 2, or 3
- Tells the compiler to run the preprocessor.
-
If the option is specified with no n, the compiler runs the preprocessor.
The default is -nofpp.
- -fpscomp [keyword]
-
Specifies the compatibility with Microsoft* Fortran PowerStation or Intel(R) Fortran. The
following are
-fpscomp
options:
-
- *
-
-fpscomp all
-
Specifies that all options should be used for Fortran PowerStation compatibility.
This is the same as specifying
-fpscomp
with no keyword. The default is
-fpscomp
libs.
- *
-
-fpscomp filesfromcmd
-
Specifies that Fortran PowerStation behavior is used when the OPEN file specifier is blank.
The default is
-fpscomp
nofilesfromcmd.
- *
-
-fpscomp general
-
Specifies that Fortran PowerStation semantics are used when differences exist with Intel(R) Fortran.
The default is
-fpscomp
nogeneral.
- *
-
-fpscomp ioformat
-
Specifies that Fortran PowerStation semantics and record format for list-directed formatted
and unformatted I/O should be used. The default is
-fpscomp
noioformat.
- *
-
-fpscomp ldio_spacing
-
Specifies that a blank should not be inserted after a numeric value before a
character value (undelimited character string). This representation is used by Intel(R) Fortran releases before Version 8.0 and by Fortran PowerStation. If you specify
-fpscomp
general,
it sets
-fpscomp
ldio_spacing.
-
The default is
-fpscomp
noldio_spacing,
which conforms to the Fortran 95 standard by inserting a blank after a numeric value before a
character value.
- *
-
-fpscomp nolibs
-
Prevents the portability library from being passed to the linker. The default is
-fpscomp
libs.
- *
-
-fpscomp logicals
-
Specifies that the integer values 1 and 0 are used to represent the LOGICAL values .TRUE. and .FALSE. respectively. This representation is used by Intel(R) Fortran releases before Version 8.0 and by Fortran PowerStation.
-
The default is
-fpscomp
nologicals,
which specifies that odd integer values are treated as true and even integer values are treated as false; specifically .TRUE. and .FALSE. are -1 and 0 respectively.
This representation is used by Compaq Visual Fortran.
- *
-
-fpscomp none
-
Specifies that no options should be used for Fortran PowerStation compatibility.
This is the same as specifying
-nofpscomp.
- -fpstkchk (i32 and i64em)
-
Generates extra code after every function call to ensure that the FP (floating-point) stack
is in the expected state. This is a deprecated option, you should use
-fp-stack-check.
- -FR
-
Specifies source files are in free format (same as the
-free
option).
- -fr32 (i64 only; L*X only)
-
Disables use of high floating-point registers. Uses only the lower 32 floating-point registers.
- -free
-
Specifies source files are in free format. By default, source file format
is determined by the file suffix.
- -fsource-asm
-
Produces an assembly file with source code annotations. To use this option, you must also specify
-S.
- -fsyntax-only
-
Specifies that the source file should be checked only for correct syntax (same as
the
-syntax-only,
-y,
and
-syntax
options).
- -ftrapuv
-
Initializes stack local variables to an unusual value to aid error detection.
Normally, these local variables should be initialized in the application.
-
The option sets any uninitialized local variables that are allocated on the stack
to a value that is typically interpreted as a very large integer or an invalid address.
References to these variables are then likely to cause run-time errors that can help
you detect coding errors.
- -ftz
-
Flushes denormal results to zero when the application is in the gradual underflow mode. It may improve performance if the denormal values are not critical to the behavior of your application. The default is -no-ftz on systems using IA-64 architecture; -ftz on systems using IA-32 architecture and systems using Intel(R) 64 architecture.
-
The following options set the -ftz option:
-fpe0,
-fpe1,
and on systems using IA-64 architecture, option
-O3.
On systems using IA-64 architecture, option
-O2
sets the
-no-ftz
option.
On systems using IA-32 architecture and systems using Intel(R) 64 architecture, every optimization option
-O
level, except
-O0,
sets -ftz.
-
Note: Option
-ftz
is a performance option. Setting it does not guarantee
that all denormals in a program are flushed to zero. It only causes denormals generated
at run time to be flushed to zero.
- -func-groups (i32 and i64em; (L*X only)
-
Enables function grouping if profiling information is enabled. The default is
-no-func-groups.
- -funroll-loops
-
Tells the compiler to use default heuristics for loop unrolling. This is the same as specifying
-unroll,
which is the recommended option.
- -fverbose-asm
-
Produces an assembly file with compiler comments, including options and version information.
To use this option, you must also specify
-S,
which sets
-fverbose-asm.
If you do not want this
default when you specify
-S,
specify
-fnoverbose-asm.
- -fvisibility=<keyword>
-
- -fvisibility-<keyword>=<file>
-
The first form specifies the default visibility for global symbols. The second form
specifies the visibility for symbols that are in a
file. The second form overrides the first form for symbols specified in <file>.
<file> is the pathname of a file containing the list of
symbols whose visibility you want to set; the symbols are separated by
whitespace (spaces, tabs, or newlines). <keyword> specifies the visibility setting; it can be any of the following:
default
- This setting means other components can reference the symbol,
and the symbol definition can be overridden (preempted) by a definition of the same
name in another component.
extern
- This setting means the symbol is treated as though
it is defined in another component. It also means that the symbol can be overridden
by a definition of the same name in another component. This setting only applies
to functions.
hidden
- This setting means other components cannot directly reference the symbol.
However, its address might be passed to other components indirectly.
internal
- This setting means
the symbol cannot be referenced outside its defining component, either directly or indirectly.
protected
- This setting means other
components can reference the symbol, but it cannot be overridden by a definition of the same name in another component.
-
If this option is specified more than once on the command line, the last
specification takes precedence over any others.
- -g
-
Produces symbolic debug information in the object file.
The compiler does not support the generation of debugging information in assemblable files.
If you specify the
-g
option, the resulting object file will contain debugging information, but the assemblable file will not.
-
On IA-32 architecture, specifying the
-g
or
-O0
option automatically sets the
-fp
option.
- -gdwarf-2
-
Enables generation of debug information using the DWARF2 format. This is currently the default when
-g
is specified.
- -gen-interfaces [[no]source]
-
Tells the compiler to generate an interface block for each routine (that is, for each SUBROUTINE and FUNCTION statement) defined in the source file.
-
The compiler generates two files for each routine, a .mod file and a .f90 file,
and places them in the current directory or in the directory specified by
the include (
-I
) or
-module
option.
The .f90 file is the text of the interface block; the .mod file is the interface
block compiled into binary form.
The default is
-nogen-interfaces.
-
If source is specified, the compiler creates the *_mod.f90 as well as the *_mod.mod
files. If nosource is specified, the compiler creates the *_mod.mod but not the
*_mod.f90 files. If neither is specified, it is the same as specifying -gen-interfaces
source.
- -heap-arrays <size>
-
Puts automatic arrays and arrays created for temporary computations on the heap instead
of the stack. <size> is an integer value representing the size of the arrays in kilobytes. Any arrays
known at compile-time to be larger than <size> are allocated on the heap instead of the stack. The default is
-no-heap-arrays.
- -help [<category>]
-
Displays all available compiler options or a category of compiler options. <category> specifies 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.
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 Optimizations (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.
-
If <category> is not specified, all available compiler options are displayed.
- -I<dir>
-
Specifies an additional directory for the include path, which is used to search
for module files (USE statement) and include files (INCLUDE statement).
- -i-dynamic
-
Causes Intel-provided libraries to be linked in dynamically. It is the opposite of
-i-static.
-i-dynamic
is a deprecated option, you should use
-shared-intel.
- -i-static
-
Causes Intel-provided libraries to be linked in statically. It is the opposite of
-i-dynamic.
-i-static
is a deprecated option, you should use
-static-intel.
- -i2
-
Makes default integer and logical variables 2 bytes long (same as the
-integer-size 16
option).
The default is
-integer-size
32.
- -i4
-
Makes default integer and logical variables 4 bytes long (same as the
-integer-size 32
option).
This is the default.
- -i8
-
Makes default integer and logical variables 8 bytes long (same as the
-integer-size 64
option).
The default is
-integer-size
32.
- -idirafter<dir>
-
Adds a directory (<dir>) to the second include file search path (after -I).
- -implicitnone
-
Sets the default type of a variable to undefined (IMPLICIT NONE).
This is the same as specifying the
-u
option.
- -inline-debug-info (L*X only)
-
Produces enhanced source position information for inlined code.
This leads to greater accuracy when reporting the source location of any instruction. It also
provides enhanced debug information useful for function call traceback. To use this option for debugging, you must also specify a debug enabling option, such as
-g.
- -inline-factor=<n>
-
Specifies the percentage multiplier that should be applied to all inlining options
that define upper limits:
-inline-max-size,
-inline-max-total-size,
-inline-max-per-routine,
and
-inline-max-per-compile.
-
This option takes the default value for each of the above options and multiplies it by <n> divided by 100. For example, if 200 is specified, all inlining options that define upper limits are multiplied by a factor of 2.
-
<n> is a positive integer specifying the percentage value. The default value is 100 (a factor of 1).
-
If you specify
-no-inline-factor,
the following occurs:
-
- *
-
Every function is considered to be a small or medium function; there are no large functions.
- *
-
There is no limit to the size a routine may grow when inline expansion is performed.
- *
-
There is no limit to the number of times some routine may be inlined into a particular routine.
- *
-
There is no limit to the number of times inlining can be applied to a compilation unit.
- -inline-forceinline
-
Specifies that an inline routine should be inlined whenever the compiler can do so.
This causes the routines marked with an inline keyword or directive to be treated as if they were [dq]forceinline[dq].
- -inline-level<n>
-
Specifies the level of inline function expansion. You can specify one of the following values for <n>:
0
- Disables inlining of user-defined functions. However, statement functions are always inlined. This is the default if
-O0
is specified.
1
-
Enables inlining when an inline keyword or an inline directive is specified.
2
- Enables inlining of any function at the discretion of the compiler. This is the default if option
-O2
is specified or is in effect by default.
- -inline-max-per-compile=<n>
-
Specifies the maximum number of times inlining may be applied to an entire compilation unit. <n> is a positive integer that specifies the maximum number.
-
For compilations using Interprocedural Optimizations (IPO), the entire compilation is a compilation unit. For other compilations, a compilation unit is a file.
-
If you specify
-no-inline-max-per-compile,
there is no limit to the number of times inlining may be applied to a compilation unit.
- -inline-max-per-routine=<n>
-
Specifies the maximum number of times the inliner may inline into a particular routine. <n> is a positive integer that specifies the maximum number.
-
If you specify
-no-inline-max-per-routine,
there is no limit to the number of times some routine may be inlined into a particular routine.
- -inline-max-size=<n>
-
Specifies the lower limit for the size of what the inliner considers to be a large routine. It specifies the boundary between what the inliner considers to be medium and large-size routines. <n> is a positive integer that specifies the minimum size of a large routine.
-
The inliner prefers to inline small routines. It has a preference against inlining large routines. So, any large routine is highly unlikely to be inlined.
-
If you specify
-no-inline-max-size,
there are no large routines. Every routine is either a small or medium routine.
- -inline-max-total-size=<n>
-
Specifies how much larger a routine can normally grow when inline expansion is performed. It limits the potential size of the routine. <n> is a positive integer that specifies the permitted increase in the size of the routine.
-
If you specify
-no-inline-max-total-size,
there is no limit to the size a routine may grow when inline expansion is performed.
- -inline-min-size=<n>
-
Specifies the upper limit for the size of what the inliner considers to be a small routine. It specifies the boundary between what the inliner considers to be small and medium-size routines. <n> is a positive integer that specifies the maximum size of a small routine.
-
The inliner has a preference to inline small routines. So, when a routine is smaller than or equal to the specified size, it is very likely to be inlined.
-
If you specify
-no-inline-min-size,
there is no limit to the size of small routines. Every routine is a small routine; there are no medium or large routines.
- -intconstant
-
Tells the compiler to use Fortran 77 semantics, rather than Fortran 95/90 semantics,
to determine the KIND for integer constants. The default is
-nointconstant.
- -integer-size <size>
-
Defines the size of INTEGER and LOGICAL variables. <size> can be 16, 32, or 64. The default
is
-integer-size
32.
- -ip
-
Enables additional interprocedural optimizations for single file compilation.
One of these optimizations enables the compiler to perform
inline function expansion for calls to functions defined within the current source
file.
- -ip-no-inlining
-
Disables full and partial inlining enabled by
-ip
or
-ipo.
- -ip-no-pinlining (i32 and i64em)
-
Disables partial inlining.
- -IPF-flt-eval-method0 (i64 only; L*X only)
-
Tells the compiler to evaluate the expressions involving floating-point operands in the
precision indicated by the variable types declared in the program. By default, intermediate
floating-point expressions are maintained in higher precision.
- -IPF-fltacc (i64 only; L*X only)
-
Disables optimizations that affect floating-point accuracy.
If the default setting is used (-IPF-fltacc-), the compiler may
apply optimizations that reduce floating-point accuracy.
You can use
-IPF-fltacc
or
-fltconsistency
to improve floating-point accuracy, but at the cost of disabling some optimizations.
- -IPF-fp-relaxed (i64 only; L*X only)
-
Enables use of faster but slightly less accurate code sequences for math
functions, such as divide and sqrt. When compared to strict IEEE* precision, this
option slightly reduces the accuracy of floating-point calculations performed by
these functions, usually limited to the least significant digit.
-
This option also enables the performance of more aggressive floating-point transformations,
which may affect accuracy.
- -IPF-fp-speculation<mode> (i64 only; L*X only)
-
Tells the compiler to speculate on floating-point (FP) operations in
one of the following <mode>s: fast, safe, strict, or off.
This a deprecated option, you should use
-fp-speculation.
- -ipo[n]
-
Enables multifile interprocedural (IP) optimizations (between files). When you specify this option, the compiler
performs inline function expansion for calls to functions defined in separate files.
-
n is an optional integer that specifies the number of object files the compiler should create. Any integer greater than or equal to 0 is valid.
-
If n is 0, the compiler decides whether to create one or more
object files based on an estimate of the size of the application.
It generates one object file for small applications, and two or
more object files for large applications.
-
If n is greater than 0, the compiler generates n object files, unless n exceeds the number of source files (m), in which case the
compiler generates only m object files.
-
If you do not specify n, the default is 0.
- -ipo-c
-
Tells the compiler to generate a multifile object file (ipo_out.o) that can be used in further link steps.
- -ipo-jobs<n> (L*X only)
-
Specifies the number of commands (jobs) to be executed simultaneously during the link phase of Interprocedural Optimization (IPO). <n> is the number of commands to run simultaneously. The number must be greater than or equal to 1. The default is
-ipo-jobs1.
-
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.
- -ipo-S
-
Tells the compiler to generate a multifile assembly file (ipo_out.s) that can be used in further link steps.
- -ipo-separate (L*X only)
-
Tells the compiler to generate one object file per source file. This option overrides any
-ipo[n]
specification.
- -isystem<dir>
-
Specifies a directory (dir) to add to the start of the system include path.
The compiler searches the specified directory for include files after it searches all directories specified by the
-I
compiler option but before it searches the standard system directories. This option is provided for compatibility with gcc.
- -ivdep-parallel (i64 only; L*X only)
-
Tells the compiler that there is no loop-carried memory dependency
in any loop following an IVDEP directive.
- -L<dir>
-
Tells the linker to search for libraries in <dir> before searching the standard directories.
- -l<string>
-
Tells the linker to search for a specified library (lib<string>) when linking.
-
Because the linker searches and processes libraries and object files in the order they
are specified, you should specify this option following the last object file it applies to.
- -logo
-
Displays the compiler version information (same as the
-V
option). The default is
-nologo.
- -lowercase
-
Causes the compiler to ignore case differences in
identifiers and to convert external names to
lowercase (same as the
-names lowercase
option). This is the default.
- -m32 (M*X only)
-
Tells the compiler to generate code for IA-32 architecture. The synonym
-arch i386
is also allowed for compatibility with gcc. Note that this option is not related to the
-arch [keyword]
option.
- -m64 (M*X only)
-
Tells the compiler to generate code for Intel(R) 64 architecture. The synonym
-arch x86_64
is also allowed for compatibility with gcc. Note that this option is not related to the
-arch [keyword]
option.
- -map-opts (L*X only)
-
Maps one or more Linux compiler options to their equivalent on a Windows system and outputs the result to stdout.
The tool can be invoked from the compiler command line or it can be used directly.
No compilation is performed when the option mapping tool is used.
Compiler options are mapped to their equivalent on the architecture you are using.
- -march=<processor> (i32 and i64em; L*X only)
-
Tells the compiler to generate code for a specified processor. You can specify one of the following values for <processor>:
-
- *
-
pentium3
-
Generates code for Intel(R) Pentium(R) III processors. This is the same as specifying
-xK.
- *
-
pentium4
-
Generates code for Intel(R) Pentium(R) 4 processors. This is the same as specifying
-xW.
- *
-
core2
-
Generates code for the Intel(R) Core(TM)2 processor family. This is the same as specifying
-xT.
-
On systems using IA-32 architecture, the compiler does not generate processor-specific code unless it is told to do so. On systems using Intel(R) 64 architecture, the default is
-march=pentium4.
-
For compatibility, a number of historical cpu values are also supported, but the generated code will not differ from the default.
- -mcmodel= <mem_model> (i64em only; L*X only)
-
Tells the compiler to use a specific memory model to generate code and store data.
This option can affect code size and performance.
You can specify one of the following values for <mem_model>:
-
- *
-
small
-
Restricts code and data to the first 2GB of address space. All
accesses of code and data can be done with Instruction Pointer (IP)-relative addressing.
This is the default.
- *
-
medium
-
Restricts code to the first 2GB; it places no memory restriction on
data. Accesses of code can be done with IP-relative addressing, but accesses of data must be done with absolute addressing.
- *
-
large
-
Places no memory restriction on code or data. All accesses of code and data must be done
with absolute addressing.
-
If your program has COMMON blocks and local data with a total size smaller than 2GB,
-mcmodel=small
is sufficient. COMMONs larger than 2GB require
-mcmodel=medium
or
-mcmodel=large.
Allocation of memory larger than 2GB can be done with any setting
of
-mcmodel.
-
IP-relative addressing requires only 32 bits, whereas absolute addressing requires 64-bits.
IP-relative addressing is somewhat faster. So, the small memory model has the least impact on performance.
-
Note: When the medium or large memory models are specified, you must also specify option
-shared-intel
to ensure that the correct dynamic versions of the Intel run-time libraries are used.
-
When shared objects (.so files) are built, position-independent code (PIC) is specified so that a single .so file can support all three memory models. The compiler driver adds
option
-fpic
to implement PIC.
-
However, you must specify a memory model for code that is to be placed in a static
library or code that will be linked statically.
- -mdynamic-no-pic (M*X32 only)
-
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.
- -mieee-fp
-
Enables improved floating-point consistency. Floating-point operations are not reordered
and the result of each floating-point operation is stored in the target variable
rather than being kept in the floating-point processor for use in a subsequent calculation.
This is the same as specifying
-fltconsistency
or
-mp.
-
The default,
-mno-ieee-fp,
provides better accuracy and run-time performance
at the expense of less consistent floating-point results.
- -mixed-str-len-arg
-
Tells the compiler that the hidden length passed for a character
argument is to be placed immediately after its corresponding character
argument in the argument list. The default is
-nomixed-str-len-arg,
which places the hidden lengths in sequential order at the end of the
argument list.
- -module <dir>
-
Specifies the directory <dir> where module (.mod) files should be placed when created
and where they should be searched for (USE statement).
- -mp
-
Maintains floating-point precision (while disabling some optimizations). The
-mp
option restricts optimization to maintain declared precision and to ensure that
floating-point arithmetic conforms more closely to the ANSI* and IEEE standards.
This is the same as specifying
-fltconsistency
or
-mieee-fp.
-
For most programs, specifying this option adversely affects performance. If you
are not sure whether your application needs this option, try compiling and
running your program both with and without it to evaluate the effects on both
performance and precision.
- -mp1
-
Improves floating-point precision and consistency. This option disables fewer optimizations
and has less impact on performance than
-fltconsistency
or
-mp.
- -mrelax (i64 only; L*X only)
-
Tells the compiler to pass linker option -relax to the linker. The default is
-mno-relax.
- -msse[n] (i32 and i64em)
-
Tells the compiler to generate code for certain Intel(R) Pentium(R) processors.
You can specify one of the following values for <n>:
2
- Generates code for Intel Pentium 4 and compatible Intel processors with Streaming
SIMD Extensions 2 (SSE2).
3
- Generates code for Intel Pentium 4 processors with Streaming SIMD Extensions 3 (SSE3).
If you do not specify n, the compiler generates code for Intel Pentium III and compatible Intel processors. On Mac OS* X systems, the only valid option is
-msse3.
- -mtune=<processor>
-
Performs optimizations for a specified processor.
On IA-32 architecture, you can specify one of the following values for <processor>:
-
- *
-
pentium
-
Optimizes for Intel(R) Pentium(R) processors.
- *
-
pentiumpro
-
Optimizes for Intel(R) Pentium(R) Pro, Intel Pentium II,
and Intel Pentium III processors.
- *
-
pentium4
-
Optimizes for Intel Pentium 4 processors. This is the default.
- *
-
pentium-mmx
-
Optimizes for Intel(R) Pentium(R) with MMX(TM) technology.
-
On Linux systems using IA-64 architecture, you can specify one of the following
values for <processor>:
-
- *
-
itanium
-
Optimizes for systems using IA-64 architecture.
- *
-
itanium2
-
Optimizes for Intel(R) Itanium(R) 2 processors.
This is the default.
- *
-
itanium2-p9000
-
Optimizes for Dual-Core Intel(R) Itanium(R) 2 Processor 9000 series. This option affects the order of the generated instructions, but the generated instructions are limited to Intel(R) Itanium(R) 2 processor instructions unless the program uses (executes) intrinsics specific to the Dual-Core Intel(R) Itanium(R) 2 processor 9000 series.
- *
-
core2
-
Optimizes for the Intel(R) Core(TM)2 processor family, including support for MMX(TM), SSE, SSE2, SSE3 and SSSE3 instruction sets.
-
This option is the same as
-mcpu,
which is deprecated.
- -names <keyword>
-
Specifies how source code identifiers and external names are interpreted.
The following are
-names
options:
-
- *
-
-names as_is
-
Causes the compiler to distinguish case differences
in identifiers and to preserve the case of external names.
- *
-
-names lowercase
-
Causes the compiler to ignore case differences in
identifiers and to convert external names to lowercase.
This is the default.
- *
-
-names uppercase
-
Causes the compiler to ignore case differences in
identifiers and to convert external names to uppercase.
- -nbs
-
Tells the compiler to treat a backslash (\) as a normal character in character literals,
not an escape character (same as the
-assume nobscc
option). This is the default.
- -no-ansi-alias
-
Tells the compiler to assume the program does not adhere to the
Fortran 95 Standard type aliasability rules. The default is
-ansi-alias,
which tells the compiler to assume that the program adheres to these
aliasability rules.
- -no-bss-init
-
Places any variables that are explicitly initialized with zeros in the DATA section.
By default, variables explicitly initialized with zeros are placed in the BSS section.
- -no-cpprt
-
Tells the compiler to use the default run-time libraries and not link to any additional C++ run-time libraries. This is the same as specifying
-no-cxxlib.
- -no-diag-id-numbers
-
Tells the compiler to output mnemonic names for driver diagnostics only.
The default is
-diag-id-numbers,
which tells the compiler to display diagnostic messages by using their ID number values.
- -no-global-hoist
-
Disables certain optimizations, such as load hoisting and speculative loads, that can move memory loads to a point earlier in the program execution than where they appear in the source.
-
This option is useful for some applications, such as those that use shared or dynamically mapped memory, which can fail if a load is moved too early in the execution stream (for example, before the memory is mapped).
-
In most cases, these optimizations are safe and can improve performance. The default,
-global-hoist,
enables these optimizations.
- -no-IPF-fma (i64 only; L*X only)
-
Disables the combining of floating-point multiplies and add/subtract operations. It also disables
the contraction of floating-point multiply and add/subtract operations into a single operation.
The default is
-IPF-fma,
which tells the compiler to combine and contract these operations whenever possible.
However, if you specify
-mp
and do not explicitly specify
-IPF-fma,
the default is
-no-IPF-fma.
- -no-prec-div
-
Enables optimizations that give slightly less precise results than
full IEEE division. With some optimizations, such as
-xN
and
-xB,
the compiler may change floating-point division computations into
multiplication by the reciprocal of the denominator. For example, A/B
is computed as A * (1/B) to improve the speed of the computation.
-
The default is
-prec-div,
which provides fully precise IEEE division. It
improves precision of floating-point divides by disabling floating-point
division-to-multiplication optimizations, resulting in greater accuracy
with some loss of performance.
- -noalign
-
Prevents the alignment of data items. This is the same as specifying
-align
none.
The default is
-align.
- -noaltparam
-
Specifies that the alternate form of parameter constant declarations (without parentheses)
should not be recognized (same as the -nodps option).
This form has no parentheses surrounding the list, and the
form of the constant, rather than implicit or explicit typing,
determines the data type of the variable.
The default is
-altparam.
- -nodefaultlibs
-
Prevents the compiler from using standard libraries when linking.
- -nodefine
-
Specifies that all preprocessor definitions apply only to
-fpp
and not to Intel(R) Fortran
conditional compilation directives. This is the same as specifying
-noD.
- -nodps
-
Specifies that the alternate form of parameter constant declarations (without parentheses)
should not be recognized (same as the -noaltparam option).
The default is
-dps.
- -nofor-main
-
Specifies the main program is not written in Fortran, and
prevents the compiler from linking for_main.o into applications.
The default is to link against the Fortran main program.
- -nolib_inline
-
Disables inline expansion of standard library or intrinsic functions.
- -nostartfiles
-
Prevents the compiler from using standard startup files when linking.
- -nostdinc
-
Removes standard directories from the include file search path (same as the
-X
option).
- -nostdlib
-
Prevents the compiler from using standard libraries and startup files when linking.
- -nus
-
Prevents the compiler from appending an underscore character to external
user-defined names. This option is the same as the
-assume nounderscore
option, and is the opposite of -us.
- -o <file>
-
Specifies the name (<file>) for an output file. The space before <file> is optional.
The output file can be any of the following:
-
- *
-
If -c is specified, it specifies the name of the generated object file.
- *
-
If
-S
is specified, it specifies the name of the generated assembly listing file.
- *
-
If
-preprocess-only
or
-P
is specified, it specifies the name of the generated preprocessor file.
-
Otherwise, -o specifies the name of the executable file.
- -O0
-
Disables all
-O<n>
optimizations. On systems using IA-32 architecture or Intel(R) 64 architecture, this option sets the
-fp
option.
- -O1
-
On systems using IA-32 architecture or Intel(R) 64 architecture, enables optimizations for speed. Also disables intrinsic recognition and the
-fp
option.
-
On systems using IA-64 architecture, the
-O1
option enables optimizations for server applications (straight-line and
branch-like code with a flat profile).
Enables optimizations for speed, while being aware of code size. For example, this option
disables software pipelining and loop unrolling.
- -O2 or -O
-
This option is the default for optimizations.
However, if
-g
is specified, the default is
-O0.
-
On systems using IA-64 architecture, the
-O2
option enables optimizations for speed, including global code scheduling,
software pipelining, predication, and speculation. It also enables:
-
- *
-
Inlining of intrinsics
- *
-
Intra-file interprocedural optimizations, which include: inlining, constant propagation, forward substitution, routine attribute propagation, variable address-taken analysis, dead static function elimination, and removal of unreferenced variables.
- *
-
The following capabilities for
performance gain: constant propagation, copy propagation, dead-code elimination,
global register allocation, global instruction scheduling and control speculation,
loop unrolling, optimized code selection, partial redundancy elimination, strength
reduction/induction variable simplification, variable renaming, exception handling
optimizations, tail recursions, peephole optimizations, structure assignment lowering
and optimizations, and dead store elimination.
- -O3
-
Enables
-O2
optimizations plus more aggressive optimizations, such as prefetching, scalar replacement,
and loop transformations. Enables optimizations for maximum speed, but does not guarantee
higher performance unless loop and memory access transformations take place.
-
On systems using IA-32 architecture or Intel(R) 64 architecture, when the
-O3
option is used with the
-ax
and
-x
options, it causes the compiler to perform more aggressive data dependency analysis than for
-O2,
which may result in longer compilation times.
-
On systems using IA-64 architecture, the
-O3
option enables optimizations for technical computing
applications (loop-intensive code): loop optimizations and data prefetch.
- -Ob<n>
-
Specifies the level of inline function expansion.
This is a deprecated option. You should use
-inline-level.
- -onetrip
-
Tells the compiler to execute at least one iteration of DO loops (same as the
-1
option).
This option has the same effect as
-f66.
- -openmp
-
Enables the parallelizer to generate multithreaded code based on OpenMP* directives. The code can be
executed in parallel on both uniprocessor and multiprocessor systems. The
-openmp
option works with both
-O0
(no optimization) and any optimization level of -O<n>. Specifying
-O0
with
-openmp
helps to debug OpenMP applications.
- -openmp-lib <type> (L*X only)
-
Lets you specify an OpenMP* run-time library to use for linking. You can specify one of the following
values for <type>:
legacy
- Tells the compiler to use the legacy OpenMP* run-time library (libguide). This setting does not provide compatibility with object files created using other compilers. This is the default.
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.
-
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
-openmp
compiler option. This is because the Fortran run-time libraries are incompatible.
-
The compatibility OpenMP run-time library is not compatible with object files created using versions of the Intel compiler earlier than 10.0.
- -openmp-profile (L*X only)
-
Enables analysis of OpenMP* applications.
To use this option, you must have Intel(R) Thread Profiler installed, which is one of the
Intel(R) Threading Tools. If this threading tool is not
installed, this option has no effect.
- -openmp-report[n]
-
Controls the level of diagnostic messages of the OpenMP parallelizer. You can specify one of the following
values for [n]:
0
- Displays no diagnostic information.
1
- Displays diagnostics indicating loops, regions, and sections successfully parallelized.
This is the default.
2
- Displays the diagnostics specified by
-openmp-report1
plus diagnostics indicating successful handling of MASTER constructs, SINGLE constructs, CRITICAL constructs, ORDERED constructs, ATOMIC directives, etc.
- -openmp-stubs
-
Enables compilation of OpenMP programs in sequential mode.
The OpenMP directives are ignored and a stub OpenMP library is linked.
- -opt-malloc-options[=<n>] (i32 and i64em)
-
Lets you specify an alternate algorithm for malloc(). <n> specifies the algorithm to use for malloc(). You can specify one of the following values for <n>:
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.
- -opt-mem-bandwidth<n> (i64 only; L*X only)
-
Enables performance tuning and heuristics that control memory bandwidth use among processors. It allows the compiler to be less aggressive with optimizations that might consume more bandwidth, so that the bandwidth can be well-shared among multiple processors for a parallel program.
-
For values of <n> greater than 0, the option tells the compiler to enable a set of performance tuning and heuristics in compiler optimizations such as prefetching, privatization, aggressive code motion, and so forth, for reducing memory bandwidth pressure and balancing memory bandwidth traffic among threads.
-
<n> is the level of optimizing for memory bandwidth usage. You can specify one of the following values for <n>:
0
- Enables a set of performance tuning and heuristics in compiler optimizations that
is optimal for serial code. This is the default for serial code.
1
- Enables a set of performance tuning and heuristics in compiler optimizations for multithreaded code generated by the compiler. This is the default if compiler option
-parallel
or
-openmp
is specified, or Cluster OpenMP option
-cluster-openmp
is specified (see the Cluster OpenMP documentation).
2
- Enables a set of performance tuning and heuristics in compiler optimizations for parallel code such as Windows Threads, pthreads, and MPI code, besides multithreaded code generated by the compiler.
- -opt-multi-version-aggressive (i32 and i64em)
-
Tells the compiler to use aggressive multi-versioning to check for pointer aliasing and scalar replacement. The default is
-no-opt-multi-version-aggressive.
- -opt-ra-region-strategy <keyword> (i32 and i64em)
-
Selects the method that the register allocator uses to partition each routine into regions.
The following are
-opt-ra-region-strategy
options:
-
- *
-
-opt-ra-region-strategy routine
-
Creates a single region for each routine.
- *
-
-opt-ra-region-strategy block
-
Partitions each routine into one region per basic block.
- *
-
-opt-ra-region-strategy trace
-
Partitions each routine into one region per trace.
- *
-
-opt-ra-region-strategy region
-
Partitions each routine into one region per loop.
- *
-
-opt-ra-region-strategy default
-
The compiler determines which method is used for partitioning.
This is the default.
- -opt-report [n]
-
Tells the compiler to generate an optimization report to stderr. n is the level of detail in the report. You can specify one of the following
values for [n]:
0
- Tells the compiler to generate no optimization report.
1
- Tells the compiler to generate a report with the minimum level of detail.
2
- Tells the compiler to generate a report with the medium level of detail. This is the default if n is not specified.
3
- Tells the compiler to generate a report with the maximum level of detail.
- -opt-report-file<file>
-
Tells the compiler to generate an optimization report named <file>.
- -opt-report-help
-
Displays the logical names of optimizer phases available for report generation (using
-opt-report-phase).
- -opt-report-level<level>
-
Specifies the detail level of the optimization report.
Tells the compiler to generate an optimization report to stderr. It also specifies the detail level in the report. This is a deprecated option, you should use
-opt-report.
- -opt-report-phase<phase>
-
Specifies the optimizer phase (<phase>) to generate reports for.
This option can be used multiple times on the same command line to generate reports
for multiple optimizer phases. Some of the possible values are:
ipo
- Interprocedural Optimizer
hlo
- High Level Optimizer
hpo
- High Performance Optimizer
ilo
- Intermediate Language Scalar Optimizer
ecg
- Code Generator (systems using IA-64 architecture only; Linux systems only)
ecg_swp
- Software pipelining component of the Code Generator (systems using IA-64 architecture only; Linux systems only)
pgo
- Profile Guided Optimization
all
- All phases
-
When one of these logical names for optimizer phases is specified for <phase>, all
reports from that optimizer phase are generated.
-
To use this option, you must also specify option
-opt-report.
-
To find all phase possibilities, use option
-opt-report-help.
- -opt-report-routine<string>
-
Generates a report on the routines containing the specified <string>
as part of their name.
If <string> is not specified, reports from all routines are generated.
- -opt-streaming-stores <keyword> (i32 and i64em)
-
Enables generation of streaming stores for optimization. The following are
-opt-streaming-stores
options:
-
- *
-
-opt-streaming-stores always
-
Enables generation of streaming stores for optimization. The compiler optimizes under the assumption that the application is memory bound.
- *
-
-opt-streaming-stores never
-
Disables generation of streaming stores for optimization. Normal stores are performed.
- *
-
-opt-streaming-stores auto
-
Lets the compiler decide which instructions to use. This is the default.
-
For this option to be effective, the compiler must be able to generate SSE2 (or higher) instructions. For more information, see compiler option
-x
or
-ax.
- -p
-
Compiles and links for function profiling with
gprof(1).
This is the same as specifying
-pg,
except that
-pg
is only available on systems using IA-32 architecture or Intel(R) 64 architecture.
- -P
-
Causes the Fortran preprocessor to send output to a file (same as the
-preprocess-only
and -F options). Note that the source file is not compiled.
- -pad
-
Enables the changing of the variable and array memory layout. The default is
-nopad.
- -pad-source
-
Specifies that fixed-form source records shorter than the statement field width
are to be padded with spaces (on the right) to the end of the statement field.
This affects the interpretation of character and Hollerith literals that are
continued across source records. The default is
-nopad-source.
- -par-report[n]
-
Controls the diagnostic information reported by the auto-parallelizer. You can specify one of the following
values for [n]:
0
- Tells the auto-parallelizer to report no diagnostic information.
1
- Tells the auto-parallelizer to report diagnostic messages for loops successfully auto-parallelized.
This is the default. Issues a [dq]LOOP AUTO-PARALLELIZED[dq] message for parallel loops.
2
- Tells the auto-parallelizer to report diagnostic messages for loops successfully auto-parallelized, as well as unsuccessful loops.
3
- Tells the auto-parallelizer to report the same diagnostic messages by
-par-report2
plus additional information about any proven or assumed dependencies inhibiting
auto-parallelization (reasons for not parallelizing).
- -par-runtime-control
-
Generates code to perform run-time checks for loops that have symbolic loop bounds. The default is
-no-par-runtime-control.
- -par-schedule-<keyword>=<n>
-
Specifies a scheduling algorithm for DO loop iterations.
<n> Is the size of the chunk or the number of iterations for each chunk (see below). <keyword> Specifies the scheduling algorithm; it can be any of the following:
static
- Divides iterations into contiguous pieces (chunks) of size n. The chunks are statically assigned to threads in the team in a round-robin fashion in the order of the thread number. 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.
dynamic
- 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. If no n is specified, the default is 1.
guided
- 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.
If no n is specified, the default is 1.
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. You cannot specify n with this keyword.
- -par-threshold[n]
-
Sets a threshold for the auto-parallelization of loops based on the probability of profitable
execution of the loop in parallel. This option is used for loops whose computation work volume
cannot be determined at compile-time. The threshold is usually relevant when the loop trip
count is unknown at compile-time.
-
[n] is an integer from 0 to 100. The default value is 100.
-
The compiler applies a heuristic that tries to balance the overhead of creating multiple threads
versus the amount of work available to be shared amongst the threads.
- -parallel
-
Tells the auto-parallelizer to generate multithreaded code for loops that can be safely
executed in parallel. To use this option, you must also specify
-O2
or
-O3.
- -pc<n> (i32 and i64em)
-
Enables control of floating-point significand precision. Some floating-point algorithms are
sensitive to the accuracy of the significand, or fractional part of the floating-point value.
For example, iterative operations like division and finding the square root can run faster
if you lower the precision with the
-pc<n>
option. You can specify one of the following values for <n>:
32
- Rounds the significand to 24 bits (single precision). Note that a change of the
default precision control or rounding mode (for example, by using the
-pc32
option or by user intervention) may affect the results returned by some of the
mathematical functions.
64
- Rounds the significand to 53 bits (double precision).
80
- Rounds the significand to 64 bits (extended precision). This is the default.
- -pg (i32 and i64em)
-
Compiles and links for function profiling with
gprof(1).
This is the same as specifying
-p,
except that
-p
is the recommended option and it is available on all systems.
- -prec-sqrt (i32 and i64em)
-
Improves precision of square root implementations; it has some speed impact.
This option inhibits any optimizations that can adversely affect the precision of a
square root computation. The result is
fully precise square root implementations, with some loss of performance.
This is the default setting if you specify
-O0,
-mp,
or
-mp1.
- -prefetch
-
Enables prefetch insertion optimization.
On IA-64 architecture, this option is enabled by default if you specify option
-O1,
-O2,
or
-O3.
To disable prefetching at these optimization levels, specify
-no-prefetch.
On IA-32 architecture and Intel(R) 64 architecture, this option enables prefetching when higher optimization levels are specified.
-
On IA-64 architecture, the default is
-prefetch.
On IA-32 architecture and Intel(R) 64 architecture, the default is
-no-prefetch.
- -preprocess-only
-
Causes the Fortran preprocessor to send output to a file (same as the
-F
and
-P
options). Note that the source file is not compiled.
- -print-multi-lib
-
Prints information about where system libraries should be found, but no compilation occurs. It is provided for compatibility with gcc.
- -prof-dir <dir>
-
Specifies a directory (<dir>) for profiling output files (*.dyn and *.dpi).
- -prof-file <file>
-
Specifies an alternate file name (<file>) for the profiling summary files.
- -prof-gen[x]
-
Instruments a program for profiling. If
-prof-genx
is specified, it instruments a program for profiling and gathers extra information for code coverage tools.
- -prof-gen-sampling (i32 only; L*X only)
-
Prepares application executables for hardware profiling (sampling) and causes the compiler to generate source code mapping information.
- -prof-use
-
Enables use of profiling information during optimization.
- -Qinstall <dir>
-
Specifies the root directory (<dir>)where the compiler installation was performed.
This option is useful if you want to use a different compiler or if you did not use the ifortvars shell script to set your environment variables.
- -Qlocation,<string>,<dir>
-
Sets <dir> as the location of the tool specified by <string>.
- -Qoption,<string>,<opts>
-
Passes options <opts> to the tool specified by <string>.
- -qp
-
Compiles and links for function profiling with
gprof(1).
This is a deprecated option, you should use
-p.
- -r8
-
Makes default real and complex variables 8 bytes long. REAL declarations are treated as DOUBLE PRECISION (REAL(KIND=8)) and COMPLEX declarations are treated as DOUBLE COMPLEX (COMPLEX(KIND=8)). This option is the same as specifying
-real-size 64
or
-autodouble.
- -r16
-
Makes default real and complex variables 16 bytes long. REAL declarations are treated as extended
precision REAL (REAL(KIND=16); COMPLEX and DOUBLE COMPLEX declarations are treated as extended
precision COMPLEX (COMPLEX(KIND=16)). This option is the same as specifying
-real-size
128.
- -rcd (i32 and i64em)
-
Enables fast float-to-integer conversions.
This option can improve the performance of code that requires
floating-point-to-integer conversions. The system default floating-point rounding mode
is round-to-nearest. However, the Fortran language requires floating-point values to be
truncated when a conversion to an integer is involved. To do this, the compiler must change
the rounding mode to truncation before each floating-point-to-integer conversion and
change it back afterwards.
-
The
-rcd
option disables the change to truncation of the rounding mode for all floating-point calculations,
including floating point-to-integer conversions. This option can improve performance, but
floating-point conversions to integer will not conform to Fortran semantics.
- -real-size <size>
-
Defines the size of REAL and COMPLEX declarations, constants, functions, and
intrinsics. <size> can be 32, 64, or 128. The default is
-real-size
32.
- -recursive
-
Specifies that all routines should be compiled for possible recursive execution.
This option sets the
-auto
option. The
default is
-norecursive.
- -reentrancy [keyword]
-
Specifies that the compiler should generate reentrant code that supports a
multithreaded application. The following are
-reentrancy
options:
-
- *
-
-reentrancy async
-
Tells the run-time library (RTL) that the program may contain asynchronous (AST)
handlers that could call the RTL. This causes the RTL to guard against AST
interrupts inside its own critical regions.
- *
-
-reentrancy none
-
Tells the run-time library (RTL) that the program does not rely on threaded or
asynchronous reentrancy. The RTL will not guard against
such interrupts inside its own critical regions. This is the default.
This option is the same as the
-noreentrancy
option.
- *
-
-reentrancy threaded
-
Tells the run-time library (RTL) that the program is multithreaded, such as
programs using the POSIX* threads library. This causes the RTL to use thread
locking to guard its own critical regions.
If you do not specify a keyword for
-reentrancy,
it is the same as specifying
-reentrancy
threaded.
- -S
-
Causes the compiler to compile to an assembly file (.s) only and not link.
- -safe-cray-ptr
-
Specifies that Cray pointers do not alias other variables.
- -save
-
Places variables, except those declared as AUTOMATIC, in static memory (same
as
-noauto
or -noautomatic). The default is
-auto-scalar.
However, if you specify
-recursive
or
-openmp,
the default is
-automatic.
- -save-temps
-
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. The default is
-no-save-temps.
- -scalar-rep (i32 only)
-
Enables scalar replacement performed during loop transformation. To use this option, you
must also specify
-O3.
The default is
-no-scalar-rep.
- -shared (L*X only)
-
Tells the compiler to produce a dynamic shared object instead of an executable.
-
On systems using IA-32 architecture or Intel(R) 64 architecture, you must specify
-fpic
for the compilation of each object file you want to include in the shared library.
- -shared-intel
-
Causes Intel-provided libraries to be linked in dynamically. It is the opposite of
-static-intel.
- -shared-libcxa (L*X only)
-
Links the Intel libcxa C++ library dynamically, overriding the default behavior when
-static
is used. It is a deprecated option.
This option is the opposite of
-static-libcxa.
- -shared-libgcc (L*X only)
-
Links the GNU libgcc library dynamically, overriding the default behavior when
-static
is used.
This option is the opposite of
-static-libgcc.
- -sox
-
Tells the compiler to save the compiler options and version number in the executable. The
default is
-no-sox.
- -ssp (i32 only; L*X only)
-
Enables Software-based Speculative Pre-computation (SSP), which is also called Helper-Threading optimization. It provides a way to dynamically prefetch data
cache blocks to counterbalance ever-increasing memory latency.
It exploits the properties of source code constructs (such as delinquent
loads and pointer-chasing loops) in applications.
- -stand [keyword]
-
Causes the compiler to issue compile-time messages for nonstandard language elements.
The following are
-stand
options:
-
- *
-
-stand f03
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 2003 (same as the
-std03
or -std options). This option is set if you specify
-warn
stderrors.
If you do not specify a keyword for
-stand,
it is the same as specifying
-stand
f03.
- *
-
-stand f90
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 90 (same as the -std90 option).
- *
-
-stand f95
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 95 (same as the
-std95
option).
- *
-
-stand none
-
Causes the compiler to issue no messages for nonstandard language elements. This is the
same as specifying
-nostand.
This is the default.
- -static (L*X only)
-
Prevents linking with shared libraries. Causes the executable to link all libraries statically.
- -static-intel
-
Causes Intel-provided libraries to be linked in statically. It is the opposite of
-shared-intel.
- -static-libcxa (L*X only)
-
Links the Intel libcxa C++ library statically. It is a deprecated option. This option is the opposite of
-shared-libcxa.
- -static-libgcc (L*X only)
-
Links the GNU libgcc library statically.
This option is the opposite of
-shared-libgcc.
- -std03 or -std
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 2003 (same as the -stand f03 option). This option is set if you specify
-warn
stderrors.
- -std90
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 90 (same as the -stand f90 option).
- -std95
-
Causes the compiler to issue messages for language elements that are not standard in
Fortran 95 (same as the -stand f95 option).
- -syntax-only
-
Specifies that the source file should be checked only for correct syntax (same as
the -fsyntax-only and -y options). No code
is generated, no object file is produced, and some error checking done by the
optimizer is bypassed.
This option lets you do a quick syntax check of your source file.
- -T <file> (L*X only)
-
Tells the linker to read link commands from the specified <file>.
- -tcheck (L*X only)
-
Enables analysis of threaded applications. To use this option, you must have Intel(R) Thread Checker installed, which is one of the Intel(R) Threading Tools.
- -tcollect[=<lib>] (L*X only)
-
Inserts instrumentation probes calling the Intel(R) Trace Collector API. To use this option, you must have the Intel(R) Trace Collector installed. <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.
- -Tf <file>
-
Specifies that <file> should be compiled as a Fortran source file. This option is useful when you have a file with a nonstandard filename suffix.
-
This option assumes the file specified uses fixed source form. If the file uses
free source form, you must also specify option
-free.
- -threads
-
Specifies that multithreaded libraries should be linked. This
is the default on systems using Intel(R) 64 architecture.
This option sets the
-reentrancy threaded
option. On systems using IA-32 architecture and IA-64 architecture, the default is
-nothreads.
- -tprofile (L*X only)
-
Generates instrumentation to analyze multi-threading performance. To use this option, you must have Intel(R) Thread Profiler installed, which is one of the Intel(R) Threading Tools.
- -traceback
-
Tells the compiler to generate extra information in the object file to
allow the display of source file traceback information at run time when a severe error occurs.
The default is
-notraceback.
- -tune <keyword> (i32 and i64em)
-
Determines the version of the architecture for which the compiler generates instructions. The following are
-tune
options:
-
- *
-
-tune pn1
-
Optimizes for the Intel(R) Pentium(R) processor.
- *
-
-tune pn2
-
Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.
- *
-
-tune pn3
-
Optimizes for the Intel(R) Pentium(R) Pro, Intel(R) Pentium(R) II, and Intel(R) Pentium(R) III processors.
This is the same as specifying the
-tune pn2
option.
- *
-
-tune pn4
-
Optimizes for the Intel(R) Pentium(R) 4 processor. This is the default.
-
The only option available on systems using Intel(R) 64 architecture is
-tune
pn4.
- -u
-
Sets the default type of a variable to undefined (IMPLICIT NONE).
This is the same as specifying the
-implicitnone
option.
- -U<name>
-
Removes the predefined macro named <name>.
- -unroll[n]
-
Sets the maximum number of times to unroll loops. Use
-unroll-loops0
to disable loop unrolling. The default is
-unroll-loops,
which tells the compiler to use default heuristics. This is the same as specifying
-funroll-loops.
- -unroll-aggressive (i32 and i64em)
-
Tells the compiler to use aggressive, complete unrolling for loops with small constant trip counts. The default is
-no-unroll-aggressive.
- -uppercase
-
Causes the compiler to ignore case differences in
identifiers and to convert external names to
uppercase (same as the
-names uppercase
option). The default
is
-lowercase
(or -names lowercase).
- -us
-
Tells the compiler to append an underscore character to external
user-defined names (opposite of -nus).
Specifying
-us
is the same as specifying the
-assume underscore
option.
- -use-asm
-
Tells the compiler to produce objects through the assembler.
- -v [file]
-
Tells the driver that tool commands should be shown and executed. If you do not specify
a file name (file), the compiler displays only the version number.
See also
-dryrun.
- -V
-
Displays the compiler version information (same as the -logo option).
- -vec-guard-write (i32 and i64em)
-
Tells the compiler to perform a conditional check in a vectorized loop. The default is
-no-vec-guard-write.
- -vec-report[n] (i32 and i64em)
-
Specifies the amount of vectorizer diagnostic information to report. You can specify one of
the following values for [n]:
0
- Produces no diagnostic information.
1
- Indicates vectorized loops. This is the default.
2
- Indicates vectorized and non-vectorized loops.
3
- Indicates vectorized and non-vectorized loops and prohibiting data dependence information.
4
- Indicates non-vectorized loops.
5
- Indicates non-vectorized loops and prohibiting data dependence information.
- -vms
-
Causes the run-time system to behave like
HP* Fortran on OpenVMS* Alpha systems and VAX* systems
(VAX FORTRAN*) in the following ways:
-
- *
-
Modifies certain defaults
-
The
-vms
option sets the
-check format
and
-check output_conversion
options.
You can override this by specifying the option on the command line.
For example, if you specify
-vms
-check
noformat,
you get
-check
noformat.
- *
-
Alignment
-
The
-vms
option does not affect the alignment of fields in records or items
in COMMON. Use
-align norecords
to pack fields of records on the next byte boundary for
compatibility with HP Fortran on OpenVMS systems.
- *
-
INCLUDE qualifiers
-
/LIST and /NOLIST are recognized at the end of the file pathname
in an INCLUDE statement at compile time.
-
If the file name in the INCLUDE statement does not specify the complete
path, the path used is the current directory.
- *
-
Quotation mark character ([dq])
-
A quotation mark is recognized as starting an octal constant
(such as [dq]177) instead of a character literal ([dq]...[dq]).
- *
-
Deleted records in relative files
-
When a record in a relative file is deleted, the
first byte of that record is set to a known character (currently [aq]@[aq]).
Attempts to read that record later result in ATTACCNON errors. The
rest of the record (the whole record, if
-vms
is not specified) is set to nulls
for unformatted files and spaces for formatted files.
- *
-
ENDFILE records
-
When an ENDFILE is performed on a sequential unit, an actual
one byte record containing a Ctrl/Z is written to the file. If
-vms
is not specified, an internal ENDFILE flag is set and the file is truncated.
-
The
-vms
option does not affect ENDFILE on relative files; such files are truncated.
- *
-
Reading deleted records and ENDFILE records
-
The run-time direct access READ routine checks the first
byte of the retrieved
record. If this byte is [aq]@[aq] or NULL ("\0"), then ATTACCNON
is returned.
-
The run-time sequential access READ routine checks to see if the
record it just read is one byte long and contains a Ctrl/Z. If this is
true, it returns EOF.
- *
-
OPEN statement effects
-
Carriage control defaults to FORTRAN if
the file is formatted, and
the unit is connected to a terminal (checked by means of
isatty(3)). Otherwise, carriage control defaults to LIST.
-
The
-vms
option affects the record length for
direct access and relative organization files. The buffer size is increased
by one (to accommodate the deleted record character).
- *
-
Implied logical unit numbers
-
Certain environment variables are recognized at run time
for ACCEPT, PRINT, and TYPE statements, and for READ and WRITE statements
that do not specify a unit number, such as: READ (*,1000).
- *
-
Treatment of blanks in input
-
The
-vms
option causes the defaults for keyword BLANK in OPEN statements
to become [aq]NULL[aq] for an explicit OPEN, and [aq]ZERO[aq] for an implicit OPEN of an
external or internal file.
- *
-
Carriage control default
-
If
-vms -ccdefault default
is specified, carriage control
defaults to FORTRAN if the file is formatted and the unit
is connected to a terminal.
- -w
-
Disables all warning messages (same as the
-nowarn
and
-warn nogeneral
options).
- -W<n>
-
Disables warnings (n=0) or enables warnings (n=1). The default is
-W1
(same as the
-warn general
option).
-W0
is the same as specifying
-warn
nogeneral,
-nowarn,
or
-w.
- -Wa,<o1>[,<o2>,...]
-
Passes options <o1>, <o2>, and so forth, to the assembler for processing.
If the assembler is not invoked, these options are ignored.
- -warn [keyword]
-
Specifies the level of diagnostic messages issued by the compiler. The following are
-warn
options:
-
- *
-
-warn all
-
Enables all warning messages. This is the same as specifying
-warn
with no keyword.
- *
-
-warn none
-
Disables all warning messages. This is the same as specifying
-nowarn.
- *
-
-warn noalignments
-
Disables warnings for data that is not naturally aligned.
The default is
-warn
alignments.
- *
-
-warn declarations
-
Enables error messages about any undeclared symbols. This option makes the default data type of a variable undefined (IMPLICIT NONE) rather than using the implicit Fortran rules.
The default is
-warn
nodeclarations.
- *
-
-warn errors
-
Tells the compiler to change all warning-level messages into error-level messages.
The default is
-warn
noerrors.
- *
-
-warn nogeneral
-
Disables all information-level and warning-level messages.
The default is
-warn
general.
- *
-
-warn ignore_loc
-
Enables warnings when %LOC is stripped from an argument.
The default is
-warn
noignore_loc.
- *
-
-warn interfaces
-
Tells the compiler to check the interfaces of all SUBROUTINEs called and FUNCTIONs invoked
in your compilation against a set of interface blocks stored separately from
the source being compiled.
-
The compiler generates a compile-time message if the interface used to
invoke a routine does not match the interface defined in a .mod file external
to the source (that is, in a .mod generated by -gen-interfaces as opposed
to a .mod file USEd in the source). The compiler looks for these .mods in the
current directory or in the directory specified by the
include (
-I
) or
-module
option.
The default is
-warn
nointerfaces.
- *
-
-warn stderrors
-
Tells the compiler to change warnings about Fortran standards violations into error messages.
This option sets the
-std03
option. If you want Fortran 95 standards violations to become errors, you should specify
-warn stderrors
and
-std95.
The default is
-warn
nostderrors.
- *
-
-warn truncated_source
-
Enables warnings when source exceeds the maximum columm width in fixed-format
source files.
The default is
-warn
notruncated_source.
- *
-
-warn uncalled
-
Enables warnings when a statement function is never called.
The default is
-warn
nouncalled.
- *
-
-warn unused
-
Enables warnings about variables that are declared but never used.
The default is
-warn
nounused.
- *
-
-warn nousage
-
Disables warnings about questionable programming practices.
The default is
-warn
usage.
- -watch [keyword]
-
Tells the compiler to display certain information to the console output window. The following are
-watch
options:
-
- *
-
-watch all
-
Enables all
-watch
options. This is the same as specifying
-watch
with no keyword.
- *
-
-watch cmd
-
Tells the compiler to display and execute driver tool commands. The default is
-watch
nocmd.
- *
-
-watch source
-
Tells the compiler to display the name of the file being compiled. The default is
-watch
nosource.
- *
-
-watch none
-
Disables all
-watch
options. This is the default.
This is the same as specifying
-nowatch.
- -WB
-
Turns a compile-time bounds check into a warning. Normally, compile-time bounds checks are errors.
- -what
-
Tells the compiler to display its detailed version string.
- -Winline
-
Enables diagnostics about what is inlined and what is not inlined.
- -Wl,<o1>[,<o2>,...]
-
Passes options <o1>, <o2>, and so forth, to the linker for processing.
If the linker is not invoked, these options are ignored.
- -Wp,<o1>[,<o2>,...]
-
Passes options <o1>, <o2>, and so forth, to the preprocessor.
If the preprocessor is not invoked, these options are ignored.
- -X
-
Removes standard directories from the include file search path (same as the
-nostdinc
option).
You can use the
-X
option with the
-I
option to prevent the compiler from searching the default path for include files and direct it to use an alternate path.
- -x<processor> (i32 and i64em)
-
Tells the compiler to generate optimized code
specialized for the processor that executes your program.
<processor> is a value used to target specific processors or microarchitectures.
The following are
-x
options:
-
- *
-
-xS
-
Can generate SSE4 Vectorizing Compiler and Media Accelerators instructions
for future Intel processors that support the instructions.
- *
-
-xT
-
Can generate SSSE3, SSE3, SSE2, and SSE instructions for Intel processors,
and it can optimize for the Intel(R) Core(TM)2 Duo processor family. This is the default on Mac OS X systems using Intel(R) 64 architecture.
- *
-
-xP
-
Can generate SSE3, SSE2, and SSE instructions for Intel processors, and
it can optimize for processors based on Intel(R) Core(TM) microarchitecture and Intel
NetBurst(R) microarchitecture, like Intel(R) Core(TM) Duo processors, Pentium(R) 4 processors
with SSE3, and Intel(R) Xeon(R) processors with SSE3. This is the default on Mac OS X systems using IA-32 architecture.
- *
-
-xO
-
Can generate SSE3, SSE2, and SSE instructions, and it can optimize for
Intel processors based on Intel(R) Core(TM) microarchitecture and Intel Netburst(R) microarchitecture.
- *
-
-xB
-
Can generate SSE2 and SSE instructions for Intel processors,
and it can optimize for the Intel(R) Pentium(R) M processors. This is a deprecated option.
- *
-
-xN
-
Can generate SSE2 and SSE instructions for Intel processors, and it can
optimize for Intel(R) Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2.
- *
-
-xW
-
Can generate SSE2 and SSE instructions, and it can optimize for Intel(R)
Pentium(R) 4 processors and Intel(R) Xeon(R) processors with SSE2. This is the default on Linux systems using Intel(R) 64 architecture. This option is the same as specifying
-march=pentium4.
- *
-
-xK
-
Can generate SSE instructions and it can optimize for Intel(R) Pentium(R) III
processors and Intel(R) Pentium(R) III Xeon(R) processors. Generated code may operate on processors
not made by Intel that support SSE instructions. This is the same as specifying
-march=pentium3.
-
On Linux* systems using Intel(R) 64 architecture, B, N, and K are not valid processor values.
-
On Mac OS* X systems using IA-32 architecture, S, T, and P are valid processor values. On
these systems, P is the default and is always set. On Mac OS X systems using Intel(R) 64
architecture, S and T are the only valid processor values. On these systems, T is the
default and is always set.
-
If you specify more than one processor value, code is generated for only the highest-performing
processor specified. The highest-performing to lowest-performing processor values are: S,
T, P, O, B, N, W, K.
-
Do not use processor values S, T, P, O, W, N, B, or K 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. For example, binaries produced with W may produce code that will not
run on Intel(R) Pentium(R) III processors or earlier processors that do not support SSE2 instructions.
-
Compiling the main program with processor values S, T, P, N, or B produces binaries
that display a fatal run-time error if they are executed on unsupported processors.
For more information, see Optimizing Applications.
-
The binaries produced by these values will run on Intel processors that support all
of the features for the targeted processor. For example, binaries produced with W will
run on an Intel(R) Core(TM)2 Duo processor, because that processor completely supports all of
the capabilities of the Intel(R) Pentium(R) 4 processor, which the W value targets. Specifying
the T value has the potential of using more features and optimizations available to the
Intel(R) Core(TM)2 Duo processor.
-
By default, the compiler does not generate optimized code specialized for the processor on Linux systems using IA-32 architecture.
- -Xlinker <value>
-
Passes <value> directly to the linker for processing.
- -y
-
Specifies that the source file should be checked only for correct syntax (same as
the
-syntax-only,
-fsyntax-only,
and
-syntax
options).
- -zero
-
Initializes to zero all local scalar variables of intrinsic type INTEGER, REAL,
COMPLEX, or LOGICAL that are saved but not yet initialized.
The default is -nozero.
Use -save on the command line to make all local variables specifically marked as SAVE.
- -Zp[n]
-
Aligns fields of records and components of derived types
on the smaller of the size boundary specified
or the boundary that will naturally align them (same as
the -align rec<n>byte
option). The [n] can be 1, 2, 4, 8, or 16.
If you do not specify [n], you get
-Zp16,
which is the default.
This version of the compiler no longer supports the following compiler options:
-cxxlib-icc,
-F
(use
-preprocess-only),
-Kpic
and
-KPIC
(use
-fpic),
-prof-format-32,
-syntax
(use
-syntax-only),
-tpp{5|6|7}
(for
-tpp7,
use
-mtune=pentium4).
The following symbols are defined on Linux systems at the start of compilation:
The following symbols are defined on Mac OS X systems at the start of compilation:
The following symbols are defined on all systems during compilation if certain compiler options are specified:
Note that some environment variables are enabled (set to true) by specifying Y, y, T, t, or 1; they are disabled (set to false) by specifying N, n, F, f, or 0.
Intel also provides a support web site that contains a rich repository of self-help information, including
getting started tips, known product issues, product errata, license information, user forums, and more.
Registering your product entitles you to one year of technical support and product updates through
Intel(R) Premier Support. Intel Premier Support is an interactive issue management and communication
web site that enables you to submit issues and review their status, and to download product updates
anytime of the day.
In addition, see these other documents provided with the Intel Fortran Compiler:
You can access these documents from <install-directory>/doc/Doc_Index.htm. The default path is /opt/intel/fc/10.1.xxx/doc/Doc_Index.htm.
Copyright (C) 1985-2007, Intel Corporation.
* Other brands and names are the property of their respective owners.