编译#
intel Fortran编译选项#
Intel(R) Fortran Compiler Help
==============================
Intel(R) Compiler includes compiler options that optimize for instruction
sets that are available in both Intel(R) and non-Intel microprocessors, but
may perform additional optimizations for Intel microprocessors than for
non-Intel microprocessors. In addition, certain compiler options for
Intel(R) Compiler are reserved for Intel microprocessors. For a detailed
description of these compiler options, including the instructions they
implicate, please refer to "Intel(R) Compiler User and Reference Guides >
Compiler Options."
usage: ifort [options] file1 [file2 ...]
where options represents zero or more compiler options
fileN is a Fortran source (.f .for .ftn .f90 .fpp .F .FOR .F90 .i .i90),
assembly (.s .S), object (.o), static library (.a), or other
linkable file
Commonly used options may be placed in the ifort .cfg file.
Some options listed are only available on a specific system
i32 indicates the feature is available on systems based on IA-32
architecture
i64em indicates the feature is available on systems using Intel(R) 64
architecture
Compiler Option List
--------------------
Optimization
------------
-O1 optimize for maximum speed, but disable some optimizations which
increase code size for a small speed benefit
-O2 optimize for maximum speed (DEFAULT)
-O3 optimize for maximum speed and enable more aggressive optimizations
that may not improve performance on some programs
-O same as -O2
-Os enable speed optimizations, but disable some optimizations which
increase code size for small speed benefit
-O0 disable optimizations
-Ofast enable -O3 -no-prec-div -fp-model fast=2 optimizations
-fno-alias
assume no aliasing in program
-fno-fnalias
assume no aliasing within functions, but assume aliasing across calls
-fast enable -xHOST -ipo -no-prec-div -O3 -static -fp-model=fast=2
optimizations
-nolib-inline
disable inline expansion of intrinsic functions
-f[no-]optimize-sibling-calls
Optimize sibling and tail recursive calls.
Enabled at levels -O2, -O3, -Os.
-f[no-]protect-parens
enable/disable(DEFAULT) a reassociation optimization for REAL
and COMPLEX expression evaluations by not honoring parenthesis
-qsimd-honor-fp-model
enforces the selected fp-model in SIMD loops.
Specify -qno-simd-honor-fp-model(DEFAULT) to override
the fp-model in SIMD loops.
-qsimd-serialize-fp-reduction
serializes FP reductions for improved floating point consistency in
SIMD loops while allowing the rest of the loop to be vectorized.
Default is -qno-simd-serialize-fp-reduction
Code Generation
---------------
-x<code> generate specialized code to run exclusively on processors
indicated by <code> as described below
SSE2 May generate Intel(R) SSE2 and SSE instructions for Intel
processors. Optimizes for the Intel NetBurst(R)
microarchitecture.
SSE3 May generate Intel(R) SSE3, SSE2, and SSE instructions for
Intel processors. Optimizes for the enhanced Pentium(R) M
processor microarchitecture and Intel NetBurst(R)
microarchitecture.
SSSE3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE
instructions for Intel processors. Optimizes for the
Intel(R) Core(TM) microarchitecture.
SSE4.1 May generate Intel(R) SSE4 Vectorizing Compiler and Media
Accelerator instructions for Intel processors. May
generate Intel(R) SSSE3, SSE3, SSE2, and SSE instructions
and it may optimize for Intel(R) 45nm Hi-k next generation
Intel Core(TM) microarchitecture.
SSE4.2 May generate Intel(R) SSE4 Efficient Accelerated String
and Text Processing instructions supported by Intel(R)
Core(TM) i7 processors. May generate Intel(R) SSE4
Vectorizing Compiler and Media Accelerator, Intel(R) SSSE3,
SSE3, SSE2, and SSE instructions and it may optimize for
the Intel(R) Core(TM) processor family.
AVX May generate Intel(R) Advanced Vector Extensions (Intel(R)
AVX), Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3,
SSE2, and SSE instructions for Intel(R) processors.
CORE-AVX2
May generate Intel(R) Advanced Vector Extensions 2
(Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3,
SSE2, and SSE instructions for Intel(R) processors.
CORE-AVX-I
May generate Intel(R) Advanced Vector Extensions (Intel(R)
AVX), including instructions in Intel(R) Core 2(TM)
processors in process technology smaller than 32nm,
Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
instructions for Intel(R) processors.
ATOM_SSE4.2
May generate MOVBE instructions for Intel(R) processors,
depending on the setting of option -minstruction.
May also generate Intel(R) SSE4.2, SSE3, SSE2, and SSE
instructions for Intel processors. Optimizes for Intel(R)
Atom(TM) processors that support Intel(R) SSE4.2 and MOVBE
instructions.
ATOM_SSSE3
May generate MOVBE instructions for Intel(R) processors,
depending on the setting of option -minstruction.
May also generate Intel(R) SSSE3, SSE3, SSE2, and SSE
instructions for Intel processors. Optimizes for the
Intel(R) Atom(TM) processor that support Intel(R) SSE
and MOVBE instructions.
MIC-AVX512
May generate Intel(R) Advanced Vector Extensions 512
(Intel(R) AVX-512) Foundation instructions, Intel(R)
AVX-512 Conflict Detection instructions, Intel(R) AVX-512
Exponential and Reciprocal instructions, Intel(R) AVX-512
Prefetch instructions for Intel(R) processors, and the
instructions enabled with CORE-AVX2. Optimizes for Intel(R)
processors that support Intel(R) AVX-512 instructions.
KNM
May generate Quad Fused Multiply Add (QFMA) and Quad
Virtual Neural Network Instruction (QVNNI) and the
instructions enabled with MIC-AVX512. Optimizes for
Intel(R) Xeon Phi(TM) product family processor code named
Knights Mill.
CORE-AVX512
May generate Intel(R) Advanced Vector Extensions 512
(Intel(R) AVX-512) Foundation instructions, Intel(R)
AVX-512 Conflict Detection instructions, Intel(R) AVX-512
Doubleword and Quadword instructions, Intel(R) AVX-512
Byte and Word instructions and Intel(R) AVX-512 Vector
Length Extensions for Intel(R) processors, and the
instructions enabled with CORE-AVX2. Optimizes for Intel(R)
processors that support Intel(R) AVX-512 instructions.
COMMON-AVX512
May generate Intel(R) Advanced Vector Extensions 512
(Intel(R) AVX-512) Foundation instructions, Intel(R)
AVX-512 Conflict Detection instructions, as well as the
instructions enabled with CORE-AVX2. Optimizes for Intel(R)
processors that support Intel(R) AVX-512 instructions.
BROADWELL
CANNONLAKE
HASWELL
ICELAKE-CLIENT (or ICELAKE)
ICELAKE-SERVER
IVYBRIDGE
KNL
KNM
SANDYBRIDGE
SILVERMONT
GOLDMONT
GOLDMONT-PLUS
TREMONT
SKYLAKE
SKYLAKE-AVX512
CASCADELAKE
KABYLAKE
COFFEELAKE
AMBERLAKE
WHISKEYLAKE
TIGERLAKE
SAPPHIRERAPIDS
May generate instructions for processors that support the
specified Intel(R) microarchitecture code name. Optimizes
for Intel(R) processors that support the specified Intel(R)
microarchitecture code name.
Keywords KNL and SILVERMONT are only available on Windows*
and Linux* systems.
-xHost generate instructions for the highest instruction set and processor
available on the compilation host machine
-ax<code1>[,<code2>,...]
generate code specialized for processors specified by <codes>
while also generating generic IA-32 instructions.
<codes> includes one or more of the following:
SSE2 May generate Intel(R) SSE2 and SSE instructions for Intel
processors.
SSE3 May generate Intel(R) SSE3, SSE2, and SSE instructions for
Intel processors.
SSSE3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE
instructions for Intel processors.
SSE4.1 May generate Intel(R) SSE4.1, SSSE3, SSE3, SSE2, and SSE
instructions for Intel processors.
SSE4.2 May generate Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2,
and SSE instructions for Intel processors.
AVX May generate Intel(R) Advanced Vector Extensions (Intel(R)
AVX), Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3,
SSE2, and SSE instructions for Intel(R) processors.
CORE-AVX2
May generate Intel(R) Advanced Vector Extensions 2
(Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3,
SSE2, and SSE instructions for Intel(R) processors.
CORE-AVX-I
May generate Intel(R) Advanced Vector Extensions (Intel(R)
AVX), including instructions in Intel(R) Core 2(TM)
processors in process technology smaller than 32nm,
Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
instructions for Intel(R) processors.
CORE-AVX512
May generate Intel(R) Advanced Vector Extensions 512
(Intel(R) AVX-512) Foundation instructions, Intel(R)
AVX-512 Conflict Detection instructions, Intel(R) AVX-512
Doubleword and Quadword instructions, Intel(R) AVX-512
Byte and Word instructions and Intel(R) AVX-512 Vector
Length Extensions for Intel(R) processors, and the
instructions enabled with CORE-AVX2.
BROADWELL
CANNONLAKE
HASWELL
ICELAKE-CLIENT (or ICELAKE)
ICELAKE-SERVER
IVYBRIDGE
KNL
KNM
SANDYBRIDGE
SILVERMONT
GOLDMONT
GOLDMONT-PLUS
TREMONT
SKYLAKE
SKYLAKE-AVX512
CASCADELAKE
KABYLAKE
COFFEELAKE
AMBERLAKE
WHISKEYLAKE
TIGERLAKE
SAPPHIRERAPIDS
May generate instructions for processors that support the
specified Intel(R) microarchitecture code name. Optimizes
for Intel(R) processors that support the specified Intel(R)
microarchitecture code name.
Keywords KNL and SILVERMONT are only available on Windows*
and Linux* systems.
MIC-AVX512
May generate Intel(R) Advanced Vector Extensions 512
(Intel(R) AVX-512) Foundation instructions, Intel(R)
AVX-512 Conflict Detection instructions, Intel(R) AVX-512
Exponential and Reciprocal instructions, Intel(R) AVX-512
Prefetch instructions for Intel(R) processors, and the
instructions enabled with CORE-AVX2.
KNM
May generate Quad Fused Multiply Add (QFMA) and Quad
Virtual Neural Network Instruction (QVNNI) and the
instructions enabled with MIC-AVX512
-arch <code>
generate specialized code to optimize for processors indicated by
<code> as described below
BROADWELL
CANNONLAKE
HASWELL
ICELAKE-CLIENT (or ICELAKE)
ICELAKE-SERVER
IVYBRIDGE
KNL
KNM
SANDYBRIDGE
SILVERMONT
GOLDMONT
GOLDMONT-PLUS
TREMONT
SKYLAKE-AVX512
SKYLAKE
CASCADELAKE
KABYLAKE
COFFEELAKE
AMBERLAKE
WHISKEYLAKE
TIGERLAKE
SAPPHIRERAPIDS
May generate instructions for processors that support
the specified Intel(R) microarchitecture code name
CORE-AVX2 May generate Intel(R) Advanced Vector Extensions 2
(Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSE3,
SSE2, SSE, and SSSE3 instructions
CORE-AVX-I May generate Float-16 conversion instructions and the
RDRND instruction, Intel(R) Advanced Vector Extensions
(Intel(R) AVX), Intel(R) SSE4.2, SSE4.1, SSE3, SSE2,
SSE, and SSSE3 instructions
AVX May generate Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3,
SSE2 and SSE instructions
SSE4.2 May generate Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2
and SSE instructions
SSE4.1 May generate Intel(R) SSE4.1, SSSE3, SSE3, SSE2 and SSE
instructions
SSSE3 May generate Intel(R) SSSE3, SSE3, SSE2 and SSE
instructions
SSE3 May generate Intel(R) SSE3, SSE2 and SSE instructions
SSE2 May generate Intel(R) SSE2 and SSE instructions
-mcpu=<cpu>
same as -mtune=<cpu>
-mtune=<cpu>
optimize for a specific <cpu>
generic - Optimizes code for the compiler's default behavior
broadwell
haswell
ivybridge
knl
knm
sandybridge
silvermont
cannonlake
icelake
skylake-avx512
skylake - Optimizes code for processors that support the
specified Intel(R) microarchitecture code name.
knl and silvermont are only available on Windows* and
Linux* systems
core-avx2 - Optimizes code for processors that support Intel(R)
Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R)
AVX, SSE4.2 SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
core-avx-i - Optimizes code for processors that support Float-16
conversion instructions and the RDRND instruction,
Intel(R) Advanced Vector Extensions (Intel(R) AVX),
Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
corei7-avx - Optimizes code for processors that support Intel(R)
Advanced Vector Extensions (Intel(R) AVX), Intel(R)
SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
corei7 - Optimizes code for processors that support Intel(R)
SSE4 Efficient Accelerated String and Text Processing
instructions. May also generate code for Intel(R) SSE4
Vectorizing Compiler and Media Accelerator, Intel(R)
SSE3, SSE2, SSE, and SSSE3 instructions
atom - Optimizes code for processors that support MOVBE
instructions, depending on the setting of option
-minstruction (Linux and macOS*) or /Qinstruction
(Windows). May also generate code for SSSE3
instructions and Intel(R) SSE3, SSE2, and SSE
instructions
core2 - Optimizes for the Intel(R) Core(TM) 2 processor
family, including support for MMX(TM), Intel(R) SSE,
SSE2, SSE3, and SSSE3 instruction sets.
pentium-mmx - Optimizes for Intel(R) Pentium(R) with MMX technology
pentiumpro - Optimizes for Intel(R) Pentium(R) Pro, Intel Pentium
II, and Intel Pentium III processors
pentium4m - Optimizes for Intel(R) Pentium(R) 4 processors with
MMX technology
pentium-m
pentium4
pentium3
pentium - Optimizes code for Intel(R) Pentium(R) processors.
Value pentium3 is only available on Linux systems
-march=<cpu>
generate code exclusively for a given <cpu>
broadwell
cannonlake
haswell
icelake
ivybridge
knl
knm
sandybridge
silvermont
skylake-avx512
skylake - Generates code for processors that support the
specified Intel(R) microarchitecture code name.
Keywords knl and silvermont are only available on
Linux* systems.
core-avx2 - Generates code for processors that support Intel(R)
Advanced Vector Extensions 2 (Intel(R) AVX2), Intel(R)
AVX, SSE4.2 SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
core-avx-i - Generates code for processors that support Float-16
conversion instructions and the RDRND instruction,
Intel(R) Advanced Vector Extensions (Intel(R) AVX),
Intel(R) SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
corei7-avx - Generates code for processors that support Intel(R)
Advanced Vector Extensions (Intel(R) AVX), Intel(R)
SSE4.2, SSE4.1, SSE3, SSE2, SSE, and SSSE3
instructions
corei7 - Generates code for processors that support Intel(R)
SSE4 Efficient Accelerated String and Text Processing
instructions. May also generate code for Intel(R) SSE4
Vectorizing Compiler and Media Accelerator, Intel(R)
SSE3, SSE2, SSE, and SSSE3 instructions
atom - Generates code for processors that support MOVBE
instructions, depending on the setting of option
-minstruction (Linux and macOS*) or /Qinstruction
(Windows). May also generate code for SSSE3
instructions and Intel(R) SSE3, SSE2, and SSE
instructions
core2 - Generates for the Intel(R) Core(TM) 2 processor
family
pentium4m - Generates for Intel(R) Pentium(R) 4 processors with
MMX technology
pentium-m
pentium4
pentium3
pentium - Generates code for Intel(R) Pentium(R) processors.
Value pentium3 is only available on Linux systems
-msse3 May generate Intel(R) SSE3, SSE2, and SSE instructions
-mssse3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE instructions
-msse4 Enable -msse4.2
-msse4.1 May generate Intel(R) SSE4.1, SSSE3, SSE3, SSE2, and SSE instructions
-msse4.2 May generate Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
instructions
-mavx May generate Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
instructions
-masm=<dialect>
generate asm instructions specified by <dialect>, which may be
att (DEFAULT) or intel
-minstruction=<keyword>
Refine instruction set output for the selected target processor
[no]movbe - Do/do not generate MOVBE instructions with ATOM_SSSE3
(requires -xATOM_SSSE3)
-f[no-]omit-frame-pointer
enable(DEFAULT)/disable use of EBP as general purpose register.
-fno-omit-frame-pointer replaces -fp
-f[no-]fat-lto-objects
enable/disable generation of true code/data when generating an
IL object using -ipo -c. Objects generated with -ffat-lto-objects
or -fno-fat-lto-objects are added unmodified to an archive when
using xiar. xiar behavior remains unchanged for an IL object
generated without specifying -f[no-]fat-lto-objects.
-f[no-]exceptions
enable(DEFAULT)/disable exception handling
-mno-sse disable the generation of SSE instructions
-fasynchronous-unwind-tables
determines whether unwind information is precise at an instruction
boundary or at a call boundary. -fno-asynchronous-unwind-tables is
the default for IA-32 architecture.
-fextend-arguments=[32|64]
By default, unprototyped scalar integer arguments are passed
in 32-bits (sign-extended if necessary).
On Intel(R) 64, unprototyped scalar integer arguments may be
extended to 64-bits.
-m32 generate code for IA-32 architecture
-m64 generate code for Intel(R) 64 architecture
-m[no-]omit-leaf-frame-pointer
determines whether the frame pointer is omitted or kept in leaf
functions
-m80387 Specify whether the compiler can use x87 instructions.
Use -mno-80387 to disable.
-mx87 Same as -m80387
-mstringop-strategy=<alg>
Override the internal decision heuristic for the particular algorithm
to use for inlining string operations. The allowed values for <alg>:
rep - Expand using i386 "rep" prefix (DEFAULT for -Os)
const_size_loop - Expand into an inline loop when size is known at
compile time (DEFAULT)
libcall - Always use a library call.
-mstringop-inline-threshold=<val>
inline calls to memcall-like (memcpy, memset) functions when the
number of bytes the functions handle are known at compile time and
less than <val>
-fcf-protection[=<arg>]
Enables Control-flow Enforcement Technology (CET) protection, which
defends your program from certain attacks that exploit
vulnerabilities.
branch - do control-flow instrumentation for indirect branches
return - do control-flow instrumentation for function returns
full - alias to specify both branch and return (same as no <arg>)
none - turn off instrumentation
-mauto-arch=<code1>[,<code2>,...]
generate multiple, feature-specific auto-dispatch code paths for x86
architecture processors if there is a performance benefit. The
accepted arguments match those of option '-ax'
Interprocedural Optimization (IPO)
----------------------------------
-[no-]ip enable(DEFAULT)/disable single-file IP optimization
within files
-ipo[n] enable multi-file IP optimization between files
-ipo-c generate a multi-file object file (ipo_out.o)
-ipo-S generate a multi-file assembly file (ipo_out.S)
-ip-no-inlining
disable full and partial inlining
-ip-no-pinlining
disable partial inlining
-ipo-separate
create one object file for every source file (overrides -ipo[n])
-ipo-jobs<n>
specify the number of jobs to be executed simultaneously during the
IPO link phase
Advanced Optimizations
----------------------
-unroll[n]
set maximum number of times to unroll loops. Omit n to use default
heuristics. Use n=0 to disable the loop unroller
-[no-]unroll-aggressive
enables more aggressive unrolling heuristics
-funroll-loops
unroll loops based on default heuristics
-[no-]scalar-rep
enable(DEFAULT)/disable scalar replacement (requires -O3)
-[no]pad enable/disable(DEFAULT) changing variable and array memory layout
-safe-cray-ptr
Cray pointers do not alias with other variables
-[no-]ansi-alias
enable(DEFAULT)/disable use of ANSI aliasing rules optimizations;
user asserts that the program adheres to these rules
-[no-]complex-limited-range
enable/disable(DEFAULT) the use of the basic algebraic expansions of
some complex arithmetic operations. This can allow for some
performance improvement in programs which use a lot of complex
arithmetic at the loss of some exponent range.
-reentrancy <keyword>
specify whether the threaded, reentrant run-time support should be
used
Keywords: none (same as -noreentrancy), threaded(DEFAULT), async
-noreentrancy
do not use threaded, reentrant run-time support
-heap-arrays [n]
temporary arrays of minimum size n (in kilobytes) are allocated in
heap memory rather than on the stack. If n is not specified,
all temporary arrays are allocated in heap memory.
-no-heap-arrays
temporary arrays are allocated on the stack (DEFAULT)
-q[no-]opt-multi-version-aggressive
enables more aggressive multi-versioning to check for pointer
aliasing and scalar replacement
-qopt-ra-region-strategy[=<keyword>]
select the method that the register allocator uses to partition each
routine into regions
routine - one region per routine
block - one region per block
trace - one region per trace
loop - one region per loop
default - compiler selects best option
-[no-]vec
enables(DEFAULT)/disables vectorization
-[no-]vec-guard-write
enables cache/bandwidth optimization for stores under conditionals
within vector loops
-vec-threshold[n]
sets a threshold for the vectorization of loops based on the
probability of profitable execution of the vectorized loop in
parallel
-vecabi=<arg>
select vector function ABI
legacy - use the legacy vector function ABI
compat - use the compatibility vector function ABI (DEFAULT)
cmdtarget - generate an extended set of vector functions
gcc - use GCC compatible ABI
-qopt-malloc-options={0|1|2|3|4}
specify malloc configuration parameters. Specifying a non-zero <n>
value will cause alternate configuration parameters to be set for
how malloc allocates and frees memory
-qopt-jump-tables=<arg>
control the generation of jump tables
default - let the compiler decide when a jump table, a series of
if-then-else constructs or a combination is generated
large - generate jump tables up to a certain pre-defined size
(64K entries)
<n> - generate jump tables up to <n> in size
use -qno-opt-jump-tables to lower switch statements as chains of
if-then-else constructs
-fno-jump-tables
do not generate jump tables for switches and if-then-else statements
-qopt-block-factor=<n>
specify blocking factor for loop blocking
-qopt-streaming-stores=<arg>
specifies whether streaming stores are generated
always - enables generation of streaming stores under the
assumption that the application is memory bound. Also,
the user is responsible for inserting the right memory
fences for synchronization
auto - compiler decides when streaming stores are used (DEFAULT)
never - disables generation of streaming stores
-qmkl[=<arg>]
link to the Intel(R) Math Kernel Library (Intel(R) MKL) and bring
in the associated headers
parallel - link using the threaded Intel(R) MKL libraries. This
is the default when -qmkl is specified
sequential - link using the non-threaded Intel(R) MKL libraries
cluster - link using the Intel(R) MKL Cluster libraries plus
the sequential Intel(R) MKL libraries
-q[no-]opt-subscript-in-range
assumes no overflows in the intermediate computation of the
subscripts
-coarray[=<keyword>]
enable/disable(DEFAULT) coarray syntax for data parallel
programming, and set the relationship between the coarray
images.
keywords: shared - default if keyword is omitted
single - overrides any other keyword
distributed - only valid with the Intel(R)
Cluster Toolkit
-coarray-num-images=n
set default number of coarray images
-q[no-]opt-matmul
replace matrix multiplication with calls to intrinsics and threading
libraries for improved performance (DEFAULT at -O3 -parallel)
-[no-]simd
enables(DEFAULT)/disables vectorization using SIMD directive
-guide-opts=<arg>
tells the compiler to analyze certain code and generate
recommendations that may improve optimizations
-guide-file[=<filename>]
causes the results of guide to be output to a file
-guide-file-append[=<filename>]
causes the results of guide to be appended to a file
-guide[=<level>]
lets you set a level (1 - 4) of guidance for auto-vectorization,
auto-parallelization, and data transformation (DEFAULT is 4 when the
option is specified)
-guide-data-trans[=<level>]
lets you set a level (1 - 4) of guidance for data transformation
(DEFAULT is 4 when the option is specified)
-guide-par[=<level>]
lets you set a level (1 - 4) of guidance for auto-parallelization
(DEFAULT is 4 when the option is specified)
-guide-vec[=<level>]
lets you set a level (1 - 4) of guidance for auto-vectorization
(DEFAULT is 4 when the option is specified)
-qopt-mem-layout-trans[=<level>]
controls the level of memory layout transformations performed by the
compiler
0 - disable memory layout transformations (same as
-qno-opt-mem-layout-trans)
1 - enable basic memory layout transformations
2 - enable more memory layout transformations (DEFAULT when the
option is specified)
3 - enable aggressive memory layout transformations
-qopt-prefetch[=n]
enable levels of prefetch insertion, where 0 disables.
n may be 0 through 5 inclusive. Default is 2.
-qno-opt-prefetch
disable(DEFAULT) prefetch insertion. Equivalent to -qopt-prefetch=0
-qopt-prefetch-distance=n1[,n2]
specify the prefetch distance (how many iterations ahead, use n1 and
n2 values such that n1>=n2) to be used for compiler generated
prefetches inside loops. n1 indicates distance from memory to L2
cache and n2 indicates distance from L2 to L1.
-qopt-prefetch-issue-excl-hint
generates PrefetchW instruction for Intel(R) microarchitecture
code name Broadwell processors and beyond when -qopt-prefetch
is also used
-qopt-threads-per-core=n
specifies the number of threads (1 - 4) per core to be used for an
application (Intel(R) MIC Architecture specific)
-qopt-streaming-cache-evict=n
specifies the cache line eviction level (0 - 3) when streaming
loads/stores are used. (Intel(R) MIC Architecture specific)
-qopt-gather-scatter-unroll=n
specify an alternative loop unroll sequence for gather and scatter
loops (Intel(R) MIC Architecture specific). Disable with
-qno-opt-gather-scatter-unroll (equivalent to n=0)
-qopt-dynamic-align
enable(DEFAULT) dynamic data alignment optimizations. Specify
-qno-opt-dynamic-align to disable
-falign-loops[=n]
specify code alignment of loops to improve performance.
n is the number of bytes for the minimum alignment boundary. It must
be a power of 2 between 1 and 4096. If n is not present, an
alignment of 16 bytes is used.
Use of -fno-align-loops (DEFAULT) sets alignment to 1.
-qopt-zmm-usage=<keyword>
Specifies the level of zmm registers usage. You can specify one of
the following:
low - Tells the compiler that the compiled program is unlikely to
benefit from zmm registers usage. It specifies that the
compiler should avoid using zmm registers unless it can
prove the gain from their usage.
high - Tells the compiler to generate zmm code without restrictions
-qoverride-limits
provides a way to override certain internal compiler limits that are
intended to prevent excessive memory usage or compile times for very
large, complex compilation units.
-q[no-]opt-multiple-gather-scatter-by-shuffles
Enables or disables the optimization for multiple adjacent
gather/scatter type vector memory references.
-m[no-]branches-within-32B-boundaries
enable/disable(DEFAULT) aligning branches and fused branches on
32-byte boundaries
Profile Guided Optimization (PGO)
---------------------------------
-prof-dir <dir>
specify directory for profiling output files (*.dyn and *.dpi)
-prof-src-root <dir>
specify project root directory for application source files to
enable relative path resolution during profile feedback on sources
below that directory
-prof-src-root-cwd
specify the current directory as the project root directory for
application source files to enable relative path resolution during
profile feedback on sources below that directory
-[no-]prof-src-dir
specify whether directory names of sources should be
considered when looking up profile records within the .dpi file
-prof-file <file>
specify file name for profiling summary file
-[no-]prof-data-order
enable/disable(DEFAULT) static data ordering with profiling
-[no-]prof-func-order
enable/disable(DEFAULT) function ordering with profiling
-[no-]prof-func-groups
enable(DEFAULT with PGO)/disable function grouping
-prof-gen[=keyword[,keyword]]
instrument program for profiling. Optional keywords are as follows.
default - Produces an instrumented object file. This is the same
as specifying the -prof-gen option with no keyword.
srcpos - Produces an instrumented object file and information
needed for using the code coverage tool.
globdata - Produces an instrumented object file that includes
information for global data layout.
threadsafe - Collects PGO data with guards for threaded
applications.
-no-prof-gen
disable profiling instrumentation
-prof-use[=<arg>]
enable use of profiling information during optimization
weighted - invokes profmerge with -weighted option to scale data
based on run durations
[no]merge - enable(default)/disable the invocation of the profmerge
tool
-no-prof-use
disable use of profiling information during optimization
-fnsplit[=<n>]
enable function splitting (enabled with /Qprof-use for IA-32 Windows)
n - positive integer indicating the threshold number. The blocks
can be placed into a different code segment if their
execution probability is less than the specified value of
range 0 <= n <= 100
use -no-fnsplit to disable
-p compile and link for function profiling with UNIX gprof tool
On IA32 and Intel(r)64, -pg is also valid
-f[no-]instrument-functions
determine whether function entry and exit points are instrumented
-prof-hotness-threshold=<val>
set the hotness threshold for function grouping and function ordering
val indicates percentage of functions to be placed in hot region.
This option requires -prof-use
and -prof-func-groups or -prof-func-order
-prof-value-profiling=<arg>[,<arg>,...]
limit value profiling
none - inhibit all types of value profiling
nodivide - inhibit value profiling of non-compile time constants
used in division or remainder operations
noindcall - inhibit value profiling of function addresses at
indirect call sites
-prof-gen-sampling
prepares application executables for hardware profiling (sampling)
and causes the compiler to generate source code mapping information
-prof-use-sampling=file[:file:...]
enable use of hardware profiling (sampling) information during
optimization. Argument provides list of one or more profiling data
files to apply
Optimization Reports
--------------------
-qopt-report[=n]
generate an optimization report. Default destination is
<target>.optrpt. Levels of 0 - 5 are valid.
Please see documentation for additional details of
information provided by phase per level.
0 disable optimization report output
2 DEFAULT when enabled
-qopt-report-file=[stdout | stderr | <file>]
specify the filename or output stream for the generated report
-qopt-report-stdout
specify the generated report should be directed to stdout
-qopt-report-per-object
specify the generated report should be directed to a .optrpt file
in the output directory (DEFAULT when another destination for the
report is not specified)
-qopt-report-phase=<phase>[,<phase>,...]
specify one or more phases that reports are generated against
-qopt-report-routine=<name>[,<name>,...]
restrict the report to routines containing the given name
-qopt-report-filter=<string>
restricts the opt-report to specific files, routines or line
number ranges. Refer to the documentation for the specific
syntax of parameter string.
-qopt-report-format=[text|vs]
specify the output format to be used for the opt-report as either
plain text or a format for use in the Microsoft* Visual Studio IDE
-q[no-]opt-report-embed
When enabled, if an assembly file is being generated, special loop
info annotations will be emitted in the assembly file. If an object
file/executable is being generated, these will be emitted into the
object file/executable for use by the Intel VTune Amplifier
application. Automatically enabled when symbolic debug information
is enabled.
-qopt-report-help
display the optimization phases available for reporting
-qopt-report-names=<keyword>
Specifies whether mangled or unmangled names should appear in the
optimization report.
mangled - use mangled names
unmangled - use unmangled names (DEFAULT)
-qopt-report-annotate[=<keyword>]
Annotate source files with optimization reports in specified format
html - annotate in HTML format
text - annotate in text format (DEFAULT)
-qopt-report-annotate-position=<keyword>
Specify the site where loop related optimization reports appear in
the annotated source for inlined routines
caller - annotate at caller site
callee - annotate at callee site
both - annotate at both caller and callee site
-tcheck [mode]
enable analysis of threaded applications (requires Intel(R) Thread
Checker; cannot be used with compiler alone)
tci - instruments a program to perform a thread-count-independent
analysis
tcd - instruments a program to perform a thread-count-dependent
analysis (DEFAULT when mode is not used)
api - instruments a program at the api-imports level
-tcollect[=<lib>]
inserts instrumentation probes calling the Intel(R) Trace Collector
API. The library -l<lib> is linked in the default being -lVT
(requires Intel(R) Trace Collector)
-tcollect-filter file
Enable or disable the instrumentation of specified functions.
(requires Intel(R) Trace Collector)
OpenMP* and Parallel Processing
------------------------------
-qopenmp enable the compiler to generate multi-threaded code based on the
OpenMP* directives (same as -fopenmp)
Use -qno-openmp to disable
-qopenmp-stubs
enables the user to compile OpenMP programs in sequential mode. The
OpenMP directives are ignored and a stub OpenMP library is linked
(sequential)
-qopenmp-lib=<ver>
choose which OpenMP library version to link with
compat - use the GNU compatible OpenMP run-time libraries
(DEFAULT)
-qopenmp-link=<library>
choose whether to link with the static or dynamic OpenMP
libraries. Default is dynamic.
-qopenmp-threadprivate=<ver>
choose which threadprivate implementation to use
compat - use the GNU compatible thread local storage
legacy - use the Intel compatible implementation
(DEFAULT)
-parallel
enable the auto-parallelizer to generate multi-threaded code for
loops that can be safely executed in parallel
-par-threshold[n]
set threshold for the auto-parallelization of loops where n is an
integer from 0 to 100
-par-runtime-control[n]
Control parallelizer to generate runtime check code for effective
automatic parallelization.
n=0 no runtime check based auto-parallelization
n=1 generate runtime check code under conservative mode
(DEFAULT when enabled)
n=2 generate runtime check code under heuristic mode
n=3 generate runtime check code under aggressive mode
-par-schedule-static[=n]
Specifies a scheduling algorithm for DO loop iteration.
Divides iterations into contiguous pieces. Size n if
specified, equal sized pieces if not.
-par-schedule-static-balanced[=n]
Divides iterations into even-sized chunks. Size n if
specified, equal sized pieces if not.
-par-schedule-static-steal[=n]
Divides iterations into even-sized chunks, but allows
threads to steal parts of chunks from neighboring threads
-par-schedule-dynamic[=n]
Specifies a scheduling algorithm for DO loop iteration.
Assigns iterations to threads in chunks dynamically.
Chunk size is n iterations if specified, otherwise 1.
-par-schedule-guided[=n]
Specifies a scheduling algorithm for DO loop iteration.
Indicates a minimum number of iterations. If specified,
n is the minimum number, otherwise 1.
-par-schedule-guided-analytical[=n]
Divides iterations by using exponential distribution or
dynamic distributions.
-par-schedule-runtime
Specifies a scheduling algorithm for DO loop iteration.
Defers the scheduling decision until runtime.
-par-schedule-auto
Lets the compiler or run-time system determine the
scheduling algorithm.
-par-affinity=[<modifier>,...]<type>[,<permute>][,<offset>]
tune application performance by setting different thread affinity
-par-num-threads=<n>
tune application performance by setting different number of threads
-parallel-source-info[=n]
enable(DEFAULT)/disable the emission of source location information
for parallel code generation with OpenMP and auto-parallelization
0 - disable (same as -no-parallel-source-info)
1 - emit routine name and line information (DEFAULT)
2 - emit path, file, routine name and line information
-qopenmp-simd
Enables OpenMP* SIMD compilation. Enabled by default with
-qopenmp. Use -qno-openmp-simd to disable.
-f[no-]mpc_privatize
Enables privatization of all static data for the MPC
unified parallel runtime. This will cause calls to
extended thread local storage resolution run-time routines
which are not supported on standard linux distributions.
This option is only usable in conjunction with the MPC
unified parallel runtime. The default is -fno-mpc-privatize.
Floating Point
--------------
-fp-model <name>
enable <name> floating point model variation
[no-]except - enable/disable floating point exception semantics
fast[=1|2] - enables more aggressive floating point optimizations
precise - allows value-safe optimizations
source - enables intermediates in source precision
sets -assume protect_parens for Fortran
strict - enables -fp-model precise -fp-model except, disables
contractions and enables pragma stdc fenv_access
consistent - enables consistent, reproducible results for
different optimization levels or between different
processors of the same architecture
-fp-speculation=<mode>
enable floating point speculations with the following <mode>
conditions:
fast - speculate floating point operations (DEFAULT)
safe - speculate only when safe
strict - same as off
off - disables speculation of floating-point operations
-pc32 set internal FPU precision to 24 bit significand
-pc64 set internal FPU precision to 53 bit significand
-pc80 set internal FPU precision to 64 bit significand (DEFAULT)
-mp1 improve floating-point precision
-mieee-fp
maintain floating point precision (disables some optimizations)
can be disabled with -mno-ieee-fp
-[no-]prec-sqrt
determine if certain square root optimizations are enabled
-[no-]prec-div
improve precision of FP divides (some speed impact)
-[no-]fast-transcendentals
generate a faster version of the transcendental functions
-[no-]fp-port
round fp results at assignments and casts (some speed impact)
-fp-stack-check
enable fp stack checking after every function/procedure call
-rcd rounding mode to enable fast float-to-int conversions
-rounding-mode chopped
set internal FPU rounding control to truncate
-[no-]ftz
enable/disable flush denormal results to zero
-fpe{0|1|3}
specifies program-wide behavior on floating point exceptions
-fpe-all={0|1|3}
specifies floating point exception behavior on all functions
and subroutines. Also sets -assume ieee_fpe_flags
-[no]fltconsistency
specify that improved floating-point consistency should be used
-[no-]fma
enable/disable the combining of floating point multiplies and
add/subtract operations
-[no]recursive
compile all procedures for possible recursive execution
-fimf-absolute-error=value[:funclist]
define the maximum allowable absolute error for math library
function results
value - a positive, floating-point number conforming to the
format [digits][.digits][{e|E}[sign]digits]
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-fimf-accuracy-bits=bits[:funclist]
define the relative error, measured by the number of correct bits,
for math library function results
bits - a positive, floating-point number
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-fimf-arch-consistency=value[:funclist]
ensures that the math library functions produce consistent results
across different implementations of the same architecture
value - true or false
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-fimf-max-error=ulps[:funclist]
defines the maximum allowable relative error, measured in ulps, for
math library function results
ulps - a positive, floating-point number conforming to the
format [digits][.digits][{e|E}[sign]digits]
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-fimf-precision=value[:funclist]
defines the accuracy (precision) for math library functions
value - defined as one of the following values
high - equivalent to max-error = 1.0
medium - equivalent to max-error = 4 (DEFAULT)
low - equivalent to accuracy-bits = 11 (single
precision); accuracy-bits = 26 (double
precision)
reference - equivalent to 'high' accuracy with correct
signaling of exceptional conditions through
the errno and status flags settings. This
setting is initially available only on Linux*
systems
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-fimf-domain-exclusion=classlist[:funclist]
indicates the input arguments domain on which math functions
must provide correct results.
classlist - defined as one of the following values:
nans, infinities, denormals, zeros
all, none, common
funclist - optional list of one or more math library functions to
which the attribute should be applied.
-fimf-force-dynamic-target[=funclist]
Instructs the compiler to use run-time dispatch in calls to math
functions
funclist - optional list of one or more math library functions to
which the attribute should be applied.
-fimf-use-svml=value[:funclist]
Instructs the compiler to implement math library functions using
the Short Vector Math Library(SVML)
value - true or false
funclist - optional comma separated list of one or more math
library functions to which the attribute should be
applied
-ffinite-math-only
Allow optimizations for floating point arithmetic that assume
arguments and results are not NaNs or Infinities
Inlining
--------
-inline-level=<n>
control inline expansion:
n=0 disable inlining
n=1 inline functions declared with ATTRIBUTES INLINE or
FORCEINLINE
n=2 inline any function, at the compiler's discretion
-f[no-]inline-functions
inline any function at the compiler's discretion
-finline-limit=<n>
set maximum number of statements a function can have and still be
considered for inlining
-inline-min-size=<n>
set size limit for inlining small routines
-no-inline-min-size
no size limit for inlining small routines
-inline-max-size=<n>
set size limit for inlining large routines
-no-inline-max-size
no size limit for inlining large routines
-inline-max-total-size=<n>
maximum increase in size for inline function expansion
-no-inline-max-total-size
no size limit for inline function expansion
-inline-max-per-routine=<n>
maximum number of inline instances in any function
-no-inline-max-per-routine
no maximum number of inline instances in any function
-inline-max-per-compile=<n>
maximum number of inline instances in the current compilation
-no-inline-max-per-compile
no maximum number of inline instances in the current compilation
-inline-factor=<n>
set inlining upper limits by n percentage
-no-inline-factor
do not set set inlining upper limits
-inline-forceinline
treat inline routines as forceinline
-inline-calloc
directs the compiler to inline calloc() calls as malloc()/memset()
-inline-min_caller-growth=<n>
set lower limit on caller growth due to inlining a single routine
-no-inline-min-caller-growth
no lower limit on caller growth due to inlining a single routine
Output, Debug, PCH
------------------
-c compile to object (.o) only, do not link
-S compile to assembly (.s) only, do not link
-fsource-asm
produce assembly file with optional source annotations (requires -S)
-f[no-]verbose-asm
produce assembly file with compiler comments (DEFAULT) (requires -S)
-fcode-asm
produce assembly file with optional code annotations (requires -S)
-use-msasm
support Microsoft* style assembly language insertion using MASM style
syntax
-Fa[file]
name assembly file (or directory for multiple files; i.e. /FaMYDIR)
-Fo[file]
name object file (or directory for multiple files; i.e. /FoMYDIR)
-o <file>
name output file
-list[=<filename>]
specify that a listing file should be generated
-list-line-len=#
overrides the default line length (80) in a listing file
-list-page-len=#
overrides the default page length (66) in a listing file
-show <keyword>
controls the contents of the listing file
keywords: all, none, [no]include, [no]map, [no]options
-g[level]
Produce symbolic debug information.
Valid [level] values:
0 - Disable generation of symbolic debug information.
1 - Emit minimal debug information for performing stack traces.
2 - Emit complete debug information. (default for -g)
3 - Emit extra information which may be useful for some tools.
-gdwarf-<version>
Enable generation of debug information using the specified DWARF
version. These options may require additional tools such as linkers
and debuggers which support these formats.
Valid <version> values:
2 - DWARF Debug Information Format Version 2.
3 - DWARF Debug Information Format Version 3. (default for -g)
4 - DWARF Debug Information Format Version 4.
-gsplit-dwarf
Generates an additional output file containing most of the debug
information. This reduces the size of objects processed by the
linker. The additional output file will be given a .dwo file
extension. This option may require additional tools which support
DWARF object files.
-debug [keyword]
Control the emission of debug information.
Valid [keyword] values:
none
Disables debug generation.
all, full (default if no keyword was specified)
Generates complete debug information.
minimal
Generates line number information.
extended
Generates complete debug information with semantic stepping
and variable locations enabled.
[no]variable-locations
Controls additional debug information useful for tracking
variable values in optimized code.
[no]semantic-stepping
Controls additional debug information useful for stepping
through optimized code.
[no]pubnames
Controls generation of the DWARF .debug_pubnames section.
[no]emit-column
Controls additional line number information with columns.
[no]inline-debug-info
Controls additional debug information for inlined code.
parallel
Emit code instrumentation useful for thread data sharing and
reentrant call detection.
-debug-parameters [keyword]
Control output of debug information for PARAMETERS.
Valid [keyword] values:
none - Disables generation of debug information for PARAMETERs.
used - Generates debug information for referenced PARAMETERs only.
all - Generates debug information for all PARAMETERs.
-nodebug-parameters
Same as "-debug-parameters none".
-grecord-gcc-switches
Record command line options in the DW_AT_producer attribute in
the DWARF debugging information.
-fvar-tracking
Same as "-debug variable-locations".
-fvar-tracking-assignments
Same as "-debug semantic-stepping".
-f[no-]dwarf2-cfi-asm
Control whether the compiler should generate CFI directives which
the assembler can use to generate unwind information, or if the
compiler should emit the unwind information directly.
-fno-merge-debug-strings
Do not merge identical debug strings in different object files.
-fno-merge-constants
Do not merge identical string constants in different object files.
-[no]d-lines
compile debug statements (indicated by D in column 1)
-DD compile debug statements, indicated by D in column 1. This option
prevents the definition of a macro named D using the command line
-Dname option (use -Dname=n syntax instead)
-ftrapuv trap uninitialized variables
-map-opts
enable option mapping tool
-print-multi-lib
print information about libraries being used
-f[no-]eliminate-unused-debug-types
When disabled, debug information for all types present in the
sources will be emitted. Using this option may cause a large
increase in the size of the debug information.
-qemit-build-options
Output the options used during the compilation to a corresponding
.dashboard file. This file is to be consumed by the dbmerge tool
and used by the dashboard tool.
-qemit-messages
Output the diagnostics emitted during the compilation to a
corresponding .dashboard file. This file is to be consumed by the
dbmerge tool and used by the dashboard tool.
Preprocessor
------------
-D<name>[=<text>]
define macro
-nodefines, -noD
specifies that any -D macros go to the preprocessor only, and not to
the compiler
-U<name> remove predefined macro
-allow nofpp-comments
If a Fortran end-of-line comment is seen within a #define, treat it
as part of the definition. Default is allow:fpp-comments
-E preprocess to stdout
-EP preprocess to stdout, omitting #line directives
-P preprocess to file, omitting #line directives
-preprocess-only
same as -P
-[no]keep keep/remove preprocessed file generated by preprocessor as input to
compiler stage. Not affected by -save-temps. Default is -nokeep
-[no]fpp run Fortran preprocessor on source files prior to compilation
-fpp-name:name
Name an alternate preprocessor executable. The name can
include the full path.
-module path
specify path where mod files should be placed and first location to
look for mod files
-I<dir> add directory to include file search path
-idirafter<dir>
add directory to the second include file search path (after -I)
-isystem<dir>
add directory to the start of the system include path
-X, -nostdinc
remove standard directories from include file search path
-B<prefix>
find libraries, headers and executables in <prefix>
-gen-dep[=filename]
generate dependency information.
If no filename is specified, output is to stdout.
Similar to -MD or -MMD
If a filename is specified, output is to filename.
Similar to -MF filename
-no-gen-dep
do not generate dependency information (default)
-gen-depshow=keyword
control what dependency information is output.
[no]intr_mod Intrinsic modules. Default is nointr_mod.
-gen-depformat=keyword
generate dependency information in the specified format.
One of: make, nmake
Component Control
-----------------
-Qoption,<tool>,<opts>
pass options <opts> to tool specified by <tool>
-Qlocation,<tool>,<dir>
set <dir> as the location of tool specified by <tool>
-Qinstall <dir>
set <dir> as root of compiler installation
Language
--------
-[no]altparam
specify if alternate form of parameter constant declarations
(without parenthesis) is recognized. Default is to recognize
-assume <keyword>
specify assumptions made by the optimizer and code generator
keywords: none, [no]byterecl, [no]buffered_io,
[no]buffered_stdout,
[no]bscc (nobscc same as -nbs),
[no]contiguous_assumed_shape, [no]contiguous_pointer,
[no]cc_omp, [no]failed_images, [no]minus0,
[no]dummy_aliases (same as -common-args),
[no]ieee_fpe_flags, [no]ieee_compares, [no]fpe_summary,
[no]nan_compares,
[no]old_boz, [no]old_complex_align,
[no]old_inquire_recl,
[no]old_logical_ldio, [no]old_logical_assign,
[no]old_ldout_format, [no]old_ldout_zero,
[no]old_maxminloc, [no]old_unit_star, [no]old_xor,
[no]protect_allocates,
[no]protect_constants, [no]protect_parens,
[no]recursion, [no]realloc_lhs, [no]2underscore,
[no]underscore (same as -us),
[no]std_intent_in, [no]std_minus0_rounding,
[no]std_mod_proc_name, [no]std_value,
[no]source_include,
[no]split_common, [no]writeable_strings
-ccdefault <keyword>
specify default carriage control for units 6 and *
keywords: default, fortran, list or none
-[no]check <keyword>
check run-time conditions. Default is -nocheck
keywords: all (same as -C), none (same as -nocheck),
[no]arg_temp_created, [no]bounds (same as -CB),
[no]assume, [no]contiguous,
[no]format, [no]output_conversion,
[no]pointers (same as -CA),
[no]shape, [no]stack, [no]teams,
[no]udio_iostat, [no]uninit (same as -CU)
-common-args
assume "by reference" subprogram arguments may alias one
another. Same as -assume dummy_aliases
-e03 issue errors for language elements that are not standard in
Fortran 2003 (same as -stand f03 -warn stderrors options)
-e95 issue errors for language elements that are not standard in
Fortran 95 (same as -stand f95 -warn stderrors options)
-e90 issue errors for language elements that are not standard in
Fortran 90 (same as -stand f90 -warn stderrors options)
-[no]extend-source [<keyword>]
specify rightmost column for fixed form sources
keywords: 72 (same as -noextend-source and -72),
80 (same as -80),
132 (same as -132. Default if you specify
-extend-source without a keyword.)
-fixed specify source files are in fixed format. Same as -FI
-nofixed indicates free format
-free specify source files are in free format. Same as -FR
-nofree indicates fixed format
-[no]mixed-str-len-arg
indicate whether hidden lengths are passed after their
character argument or after all arguments.
-names <keyword>
specify how source code identifiers and external names are
interpreted.
keywords: as_is, lowercase, uppercase
-[no]pad-source
make compiler acknowledge blanks at the end of a line
-stand [<keyword>]
specifies level of conformance with ANSI standard to check
for. If keyword is not specified, level of conformance is f18
keywords: f90 (same as -std90), f95 (same as -std95),
f03 (same as -std03), f08 (same as -std08),
f18 (same as -std18),none (same as -nostand)
-standard-semantics
explicitly sets assume keywords to conform to the semantics
of the Fortran standard. May result in performance loss.
assume keywords set by -standard-semantics:
byterecl, failed_images, fpe_summary, ieee_compares, minus0,
noold_inquire_recl, noold_ldout_format, noold_ldout_zero,
noold_maxminloc, noold_unit_star, noold_xor, protect_parens,
realloc_lhs, recursion, std_intent_in, std_minus0_rounding,
std_mod_proc_name, std_value
also sets -fpscomp logicals
If -fp-model=strict or -fp-model=except is set
then this also sets assume keyword ieee_fpe_flags
-[no]standard-realloc-lhs
explicitly sets assume keyword realloc_lhs to conform to the
standard, or to override the default. Sets -assume [no]realloc_lhs
-syntax-only
perform syntax and semantic checking only (no object file produced)
-qopt-assume-safe-padding
assume that variables and dynamically allocated memory are padded
(Intel(R) MIC Architecture specific)
-[no-]wrap-margin
controls right margin wrapping in list-directed output. By default,
list-directed output is wrapped at 80 characters.
Compiler Diagnostics
--------------------
-w disable all warnings
-W<n> disable warnings (n = 0) or show warnings (n = 1 DEFAULT, same as
-warn general)
-warn <keyword>
specifies the level of warning messages issued
keywords: all, none (same as -nowarn)
[no]alignments, [no]declarations,
[no]errors, [no]externals,
[no]general, [no]ignore_loc, [no]interfaces,
[no]shape, [no]stderrors, [no]truncated_source,
[no]uncalled, [no]unused, [no]usage
-nowarn suppress all warning messages
-WB turn a compile-time bounds check into a warning
-Winline enable inline diagnostics
-[no]traceback
specify whether the compiler generates PC correlation data used to
display a symbolic traceback rather than a hexadecimal traceback at
runtime failure
-[no]gen-interfaces[:[no]source]
generate interface blocks for all routines in the file. Can be
checked using -warn interfaces
nosource indicates temporary source files should not be saved
-error-limit <size>
specify the maximum number of error-level or fatal-level compiler
errors allowed
-noerror-limit
set no maximum number on error-level or fatal-level error messages
-diag-enable=<v1>[,<v2>,...]
enable the specified diagnostics or diagnostic groups
-diag-disable=<v1>[,<v2>,...]
disable the specified diagnostics or diagnostic groups
where <vN> may be individual diagnostic numbers or group names.
where group names include:
openmp - diagnostics issued by the OpenMP* parallelizer
warn - diagnostics that have "warning" severity level
error - diagnostics that have "error" severity level
remark - diagnostics that are remarks or comments
vec - diagnostics issued by the vectorizer
par - diagnostics issued by the auto-parallelizer
cpu-dispatch
- specifies the CPU dispatch remarks
-diag-error=<v1>[,<v2>,...]
output the specified diagnostics or diagnostic groups as errors
-diag-warning=<v1>[,<v2>,...]
output the specified diagnostics or diagnostic groups as warnings
-diag-remark=<v1>[,<v2>,...]
output the the specified diagnostics or diagnostic groups as remarks
-diag-dump
display the currently enabled diagnostic messages to stdout
-diag-file[=<file>]
<file> where diagnostics are emitted to. Not specifying this causes
messages to be output to stderr
-diag-file-append[=<file>]
<file> where diagnostics are emitted to. When <file> already exists,
output is appended to the file
-[no-]diag-id-numbers
enable(DEFAULT)/disable the diagnostic specifiers to be output in
numeric form
-diag-error-limit=<num>
specify the maximum number of errors emitted
Miscellaneous
-------------
-[no]logo
display compiler version information. -nologo disables the output
-V display compiler version information
-dumpmachine
display the target machine only
--version
display GCC style version information
-sox[=<keyword>[,keyword]]
enable saving of compiler options, version and additional information
in the executable. Use -no-sox to disable(DEFAULT)
profile - include profiling data
inline - include inlining information
-save-temps
store the intermediate files in current directory and name them
based on the source file. Only saves files that are generated by
default
-dryrun show driver tool commands but do not execute tools
-v show driver tool commands and execute tools
-what display detailed compiler version information
-watch=<keyword>
tells the driver to output processing information
keywords: all, none (same as -nowatch), [no]source,
[no]cmd (same as -v)
-nowatch suppress processing information output (DEFAULT)
-Tf<file>
compile file as Fortran source
-multiple-processes[=<n>]
create multiple processes that can be used to compile large numbers
of source files at the same time
-qnextgen
invokes the Intel Compiler for LLVM*
-qnextgen-diag
This option causes the Intel Compiler for LLVM* to display a list
of compiler options that are currently not supported.
Data
----
-i{2|4|8}
set default KIND of integer and logical variables to 2, 4, or 8
-integer-size <size>
specifies the default size of integer and logical variables
size: 16, 32, 64
-r{8|16} set default size of real to 8 or 16 bytes
-real-size <size>
specify the size of REAL and COMPLEX declarations, constants,
functions, and intrinsics
size: 32, 64, 128
-autodouble
same as -real-size 64 or -r8
-double-size <size>
defines the size of DOUBLE PRECISION and DOUBLE COMPLEX declarations,
constants, functions, and intrinsics
size: 64, 128
-[no]fpconstant
extends the precision of single precision constants assigned to
double precision variables to double precision
-[no]intconstant
use Fortran 77 semantics, rather than Fortran 90/95, to determine
kind of integer constants
-auto make all local variables AUTOMATIC
-auto-scalar
make scalar local variables AUTOMATIC (DEFAULT)
-save save all variables (static allocation) (same as -noauto,
opposite of -auto)
-[no]zero
enable/disable(DEFAULT) implicit initialization to zero of local
scalar variables of intrinsic type INTEGER, REAL, COMPLEX, or
LOGICAL that are saved and not initialized
-init=<keyword>
enable/disable(DEFAULT) implicit initialization of local
variables of intrinsic type INTEGER, REAL, COMPLEX, or
LOGICAL that are saved and not initialized
The <keyword> specifies the initial value
keywords: zero (same as -zero),
snan (valid only for floating point variables),
infinity, minus_infinity (valid only for floating point)
tiny, minus_tiny (valid only for floating point)
huge, minus_huge
arrays
-dyncom<common1,common2,...>
make given common blocks dynamically-allocated
-Zp[n] specify alignment constraint for structures (n=1,2,4,8,16
-Zp16 DEFAULT)
-[no]align
analyze and reorder memory layout for variables and arrays
-align <keyword>
specify how data items are aligned
keywords: all (same as -align), none (same as -noalign),
[no]commons, [no]dcommons,
[no]qcommons, [no]zcommons,
rec1byte, rec2byte, rec4byte,
rec8byte, rec16byte, rec32byte,
array8byte, array16byte, array32byte,
array64byte, array128byte, array256byte,
[no]records, [no]sequence
-fminshared
Compilation is for the main executable. Absolute addressing can be
used and non-position independent code generated for symbols that
are at least protected
-fcommon Enables the compiler to treat common variables as if they were
defined. That in turn allows the use of gprel addressing of common
data variables. -fno-common disables
-fstack-security-check
enable overflow security checks.
-fno-stack-security-check disables (DEFAULT)
-fstack-protector
enable stack overflow security checks.
-fno-stack-protector disables (DEFAULT)
-fstack-protector-strong
enable stack overflow security checks for routines with any buffer.
-fno-stack-protector-strong disables (DEFAULT)
-fstack-protector-all
enable stack overflow security checks including functions.
-fno-stack-protector-all disables (DEFAULT)
-fpic, -fPIC
generate position independent code (-fno-pic/-fno-PIC is DEFAULT)
-fpie, -fPIE
generate position independent code that will be linked into an
executable (-fno-pie/-fno-PIE is DEFAULT)
-[no-]global-hoist
enable(DEFAULT)/disable external globals are load safe
-f[no-]keep-static-consts
enable/disable(DEFAULT) the ability to preserve allocation of
variables that are not referenced in the source
-fpack-struct
pack structure members together
-f[no-]math-errno
set ERRNO after calling standard math library functions
-no-bss-init
disable placement of zero-initialized variables in BSS (use DATA)
-f[no-]zero-initialized-in-bss
put explicitly zero initialized variables into the DATA section
instead of the BSS section
-mcmodel=<size>
use a specific memory model to generate code and store data
small - Restricts code and data to the first 2GB of address
space (DEFAULT)
medium - Restricts code to the first 2GB; it places no memory
restriction on data
large - Places no memory restriction on code or data
-convert <keyword>
specify the format of unformatted files containing numeric data
keywords: big_endian, cray, ibm, little_endian, native, vaxd, vaxg
-falign-functions=<n>
align the start of functions on a 2 (DEFAULT) or <n> byte boundary
where <n> is a power of 2
-falign-functions
align the start of functions to an optimal machine-dependent value.
-fno-align-functions (DEFAULT) aligns on a 2-byte boundary
-fvisibility=[extern|default|protected|hidden|internal]
Global symbols (data and functions) will get the visibility
attribute given by default. Symbol visibility attributes explicitly
set in the source code or using the symbol visibility attribute
file options will override the -fvisibility setting
-fvisibility-extern=<file>
Space separated symbols listed in the <file> argument will get
visibility set to extern
-fvisibility-default=<file>
Space separated symbols listed in the <file> argument will get
visibility set to default
-fvisibility-protected=<file>
Space separated symbols listed in the <file> argument will get
visibility set to protected
-fvisibility-hidden=<file>
Space separated symbols listed in the <file> argument will get
visibility set to hidden
-fvisibility-internal=<file>
Space separated symbols listed in the <file> argument will get
visibility set to internal
-fvisibility-inlines-hidden
mark inline member functions as hidden
Compatibility
-------------
-fpscomp <keyword>
specify the level of compatibility to adhere to with Fortran
PowerStation
keywords: all, none (same as -nofpscomp), [no]filesfromcmd,
[no]general, [no]ioformat, [no]ldio_spacing,
[no]libs, [no]logicals
-nofpscomp
no specific level of compatibility with Fortran PowerStation
-f66, -66
allow extensions that enhance FORTRAN-66 compatibility
-f77rtl specify that the Fortran 77 specific run-time support should be used
-nof77rtl disables
-vms enable VMS I/O statement extensions
-gcc-name=<name>
name and location of gcc if not where expected
-gxx-name=<name>
name and location of g++ if not where expected
-gnu-prefix=prefix
specify a prefix that will be added to the names of GNU utilities
called from the compiler
Linking/Linker
--------------
-L<dir> instruct linker to search <dir> for libraries
-l<string>
instruct the linker to link in the -l<string> library
-shared-intel
link Intel provided libraries dynamically
-static-intel
link Intel provided libraries statically
-shared-libgcc
link libgcc dynamically
-static-libgcc
link libgcc statically
-static-libstdc++
link libstdc++ statically
-dynamic-linker<file>
select dynamic linker other than the default
-cxxlib link using C++ run-time libraries
-no-cxxlib
do not link in C++ runtime libraries
-cxxlib[=dir]
link using C++ run-time libraries provided with gcc dir is an
optional top-level location for the gcc binaries and libraries
-nodefaultlibs
do not use standard libraries when linking
-nostartfiles
do not use standard startup files when linking
-nostdlib
do not use standard libraries and startup files when linking
-nofor-main
do not link against Fortran main object. Used when linking Fortran
objects with C main program
-static prevents linking with shared libraries
-shared produce a shared object
-Bstatic specify following libraries are linked statically
-Bdynamic
specify following libraries are linked dynamically
-pthread use POSIX* thread library for multithreading support
Same as -threads
-cxxlib-<mode>
tell the compiler which C++ run-time libraries to use
nostd - do not link in standard C++ library
-T <file>
direct linker to read link commands from <file>
-Xassembler <val>
pass <val> directly to the assembler for processing
-Xlinker <val>
pass <val> directly to the linker for processing
-Wa,<o1>[,<o2>,...]
pass options o1, o2, etc. to the assembler
-Wl,<o1>[,<o2>,...]
pass options o1, o2, etc. to the linker for processing
-Wp,<o1>[,<o2>,...]
pass options o1, o2, etc. to the preprocessor
-threads specify that multi-threaded libraries should be linked against
-nothreads disables multi-threaded libraries
-pie,-no_pie
generate position independent code that will be linked into an
executable (-pie is DEFAULT for macOS* 10.7 and later)
-no-pie/-no_pie disables position independent code
-fuse-ld=<arg>
Use different linker instead of default linker (ld)
bfd - use bfd linker
gold - use gold linker
Linker Specific Options
-----------------------
These options are specific to the linker. Details can be found in the linker
documentation and man page
-L<dir>
-T<arg>
-h<arg>
-u<arg>
-z<arg>
-i
-r
-s
-N
-Bsymbolic
-Bdynamic
-Bstatic
Deprecated Options
------------------
-use-asm No replacement
-qopt-report [n] use -qopt-report[=n]
-cilk-serialize No replacement
-qcf-protection=shadow_stack use -fcf-protection=return
-qcf-protection=branch_tracking use -fcf-protection=branch
-qcf-protection=[full|none] use -fcf-protection=[full|none]
-march=icelake use -march=icelake-client
-mtune=icelake use -mtune=icelake-client
-mcpu=icelake use -mcpu=icelake-client
-xICELAKE use -xICELAKE-CLIENT
-axICELAKE use -axICELAKE-CLIENT
-mkl use -qmkl
-mkl=parallel use -qmkl=parallel
-mkl=sequential use -qmkl=sequential
-mkl=cluster use -qmkl=cluster
-tbb use -qtbb
-ipp use -qipp
-ipp=common use -qipp=common
-ipp=crypto use -qipp=crypto
-ipp=nonpic use -qipp=nonpic
-ipp=nonpic_crypto use -qipp=nonpic_crypto
-ipp-link use -qipp-link
-ipp-link=dynamic use -qipp-link=dynamic
-ipp-link=shared use -qipp-link=shared
-ipp-link=static use -qipp-link=static
-daal use -qdaal
-daal=parallel use -qdaal=parallel
-daal=sequential use -qdaal=sequential
-prof-gen-sampling No replacement
-prof-use-sampling No replacement
-fms-dialect=11 No replacement
-fms-dialect=12 No replacement
-fms-dialect=14 No replacement
-fms-dialect=14.1 No replacement
-help [category] print full or category help message
Valid categories include
advanced - Advanced Optimizations
codegen - Code Generation
compatibility - Compatibility
component - Component Control
data - Data
deprecated - Deprecated Options
diagnostics - Compiler Diagnostics
float - Floating Point
help - Help
inline - Inlining
ipo - Interprocedural Optimization (IPO)
language - Language
link - Linking/Linker
misc - Miscellaneous
opt - Optimization
output - Output
pgo - Profile Guided Optimization (PGO)
preproc - Preprocessor
reports - Optimization Reports
openmp - OpenMP and Parallel Processing
Copyright (C) 1985-2022, Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
intel mpi 编译选项#
这里只展示mpi部分，其它部分与ifort的设置一样
Simple script to compile and/or link MPI programs.
Usage: mpiifort [options] <files>
----------------------------------------------------------------------------
The following options are supported:
-fc=<name> | -f90=<name>
specify a FORTRAN compiler name: i.e. -fc=ifort
-echo print the scripts during their execution
-show show command lines without real calling
-show_env show environment variables
-config=<name> specify a configuration file: i.e. -config=ifort for mpif90-ifort.conf file
-v print version info of mpiifort and its native compiler
-profile=<name> specify a profile configuration file (an MPI profiling
library): i.e. -profile=myprofile for the myprofile.cfg file.
As a special case, lib<name>.so or lib<name>.a may be used
if the library is found
-check_mpi link against the Intel(R) Trace Collector (-profile=vtmc).
-static_mpi link the Intel(R) MPI Library statically
-mt_mpi link the thread safe version of the Intel(R) MPI Library
-ilp64 link the ILP64 support of the Intel(R) MPI Library
-no_ilp64 disable ILP64 support explicitly
-fast the same as -static_mpi + pass -fast option to a compiler.
-t or -trace
link against the Intel(R) Trace Collector
-trace-imbalance
link against the Intel(R) Trace Collector imbalance library
(-profile=vtim)
-dynamic_log link against the Intel(R) Trace Collector dynamically
-static use static linkage method
-nostrip turn off the debug information stripping during static linking
-O enable optimization
-link_mpi=<name>
link against the specified version of the Intel(R) MPI Library
i.e -link_mpi=opt|opt_mt|dbg|dbg_mt
-norpath disable rpath for compiler wrapper of the Intel(R) MPI Library
All other options will be passed to the compiler without changing.
----------------------------------------------------------------------------
The following environment variables are used:
I_MPI_ROOT the Intel(R) MPI Library installation directory path
I_MPI_F90 or MPICH_F90
the path/name of the underlying compiler to be used
I_MPI_FC_PROFILE or I_MPI_F90_PROFILE or MPIF90_PROFILE
the name of profile file (without extension)
I_MPI_COMPILER_CONFIG_DIR
the folder which contains configuration files *.conf
I_MPI_TRACE_PROFILE
specify a default profile for the -trace option
I_MPI_CHECK_PROFILE
specify a default profile for the -check_mpi option
I_MPI_LINK specify the version of the Intel(R) MPI Library
I_MPI_DEBUG_INFO_STRIP
turn on/off the debug information stripping during static linking
----------------------------------------------------------------------------
GNU编译选项#
详情请见GNU官网的在线文档https://gcc.gnu.org/