· 9 years ago · Nov 16, 2016, 07:10 AM
1 Intel(R) C++ Compiler Help
2 ==========================
3
4
5
6 Intel(R) Compiler includes compiler options that optimize for instruction
7 sets that are available in both Intel(R) and non-Intel microprocessors, but
8 may perform additional optimizations for Intel microprocessors than for
9 non-Intel microprocessors. In addition, certain compiler options for
10 Intel(R) Compiler are reserved for Intel microprocessors. For a detailed
11 description of these compiler options, including the instructions they
12 implicate, please refer to "Intel(R) Compiler User and Reference Guides >
13 Compiler Options."
14
15
16
17 usage: icc [options] file1 [file2 ...]
18 icpc [options] file1 [file2 ...]
19
20 where options represents zero or more compiler options
21
22 fileN is a C/C++ source (.C .c .cc .cpp .cxx .c++ .i .ii),
23 assembly (.s .S), object (.o), static library (.a), or other
24 linkable file
25
26 The icpc command uses the same compiler options as the icc
27 command. Invoking the compiler using icpc compiles .c and .i files
28 as C++. Invoking the compiler using icc compiles .c and .i files as
29 C. Using icpc always links in C++ libraries. Using icc only
30 links in C++ libraries if C++ source is provided on the command line.
31
32 Commonly used options may be placed in the icc .cfg file.
33
34
35
36 Some options listed are only available on a specific system
37 i32 indicates the feature is available on systems based on IA-32
38 architecture
39 i64em indicates the feature is available on systems using Intel(R) 64
40 architecture
41
42
43
44 Compiler Option List
45 --------------------
46
47
48Optimization
49------------
50
51
52
53-O1 optimize for maximum speed, but disable some optimizations which
54 increase code size for a small speed benefit
55
56-O2 optimize for maximum speed (DEFAULT)
57
58-O3 optimize for maximum speed and enable more aggressive optimizations
59 that may not improve performance on some programs
60
61-O same as -O2
62
63-Os enable speed optimizations, but disable some optimizations which
64 increase code size for small speed benefit
65
66-O0 disable optimizations
67
68-fast enable -xHOST -O3 -ipo -no-prec-div -static -fp-model fast=2
69
70-Ofast enable -O3 -no-prec-div -fp-model fast=2 optimizations
71
72-fno-alias
73 assume no aliasing in program
74
75-fno-fnalias
76 assume no aliasing within functions, but assume aliasing across calls
77
78-f[no-]builtin
79 disable inline expansion of intrinsic functions
80
81-fno-builtin-<func>
82 disable the <func> intrinsic
83
84-ffunction-sections
85 separate functions for the linker (COMDAT)
86
87-fdata-sections
88 place each data item into its own section
89
90-f[no-]defer-pop
91 disable optimizations which may result in
92 deferred clearance of the stack arguments
93
94-nolib-inline
95 disable inline expansion of intrinsic functions
96
97-f[no-]optimize-sibling-calls
98 Optimize sibling and tail recursive calls.
99 Enabled at levels -O2, -O3, -Os.
100
101-f[no-]protect-parens
102 enable/disable(DEFAULT) a reassociation optimization for REAL
103 and COMPLEX expression evaluations by not honoring parenthesis
104
105
106Code Generation
107---------------
108
109
110
111-x<code> generate specialized code to run exclusively on processors
112 indicated by <code> as described below
113
114 SSE2 May generate Intel(R) SSE2 and SSE instructions for Intel
115 processors. Optimizes for the Intel NetBurst(R)
116 microarchitecture.
117 SSE3 May generate Intel(R) SSE3, SSE2, and SSE instructions for
118 Intel processors. Optimizes for the enhanced Pentium(R) M
119 processor microarchitecture and Intel NetBurst(R)
120 microarchitecture.
121
122 SSSE3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE
123 instructions for Intel processors. Optimizes for the
124 Intel(R) Core(TM) microarchitecture.
125
126 SSE4.1 May generate Intel(R) SSE4 Vectorizing Compiler and Media
127 Accelerator instructions for Intel processors. May
128 generate Intel(R) SSSE3, SSE3, SSE2, and SSE instructions
129 and it may optimize for Intel(R) 45nm Hi-k next generation
130 Intel Core(TM) microarchitecture.
131
132 SSE4.2 May generate Intel(R) SSE4 Efficient Accelerated String
133 and Text Processing instructions supported by Intel(R)
134 Core(TM) i7 processors. May generate Intel(R) SSE4
135 Vectorizing Compiler and Media Accelerator, Intel(R) SSSE3,
136 SSE3, SSE2, and SSE instructions and it may optimize for
137 the Intel(R) Core(TM) processor family.
138 AVX May generate Intel(R) Advanced Vector Extensions (Intel(R)
139 AVX), Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3,
140 SSE2, and SSE instructions for Intel(R) processors.
141 CORE-AVX2
142 May generate Intel(R) Advanced Vector Extensions 2
143 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3,
144 SSE2, and SSE instructions for Intel(R) processors.
145 CORE-AVX-I
146 May generate Intel(R) Advanced Vector Extensions (Intel(R)
147 AVX), including instructions in Intel(R) Core 2(TM)
148 processors in process technology smaller than 32nm,
149 Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
150 instructions for Intel(R) processors.
151
152 ATOM_SSE4.2
153 May generate MOVBE instructions for Intel(R) processors,
154 depending on the setting of option -minstruction.
155 May also generate Intel(R) SSE4.2, SSE3, SSE2, and SSE
156 instructions for Intel processors. Optimizes for Intel(R)
157 Atom(TM) processors that support Intel(R) SSE4.2 and MOVBE
158 instructions.
159 ATOM_SSSE3
160 May generate MOVBE instructions for Intel(R) processors,
161 depending on the setting of option -minstruction.
162 May also generate Intel(R) SSSE3, SSE3, SSE2, and SSE
163 instructions for Intel processors. Optimizes for the
164 Intel(R) Atom(TM) processor that support Intel(R) SSE
165 and MOVBE instructions.
166 MIC-AVX512
167 May generate Intel(R) Advanced Vector Extensions 512
168 (Intel(R) AVX-512) Foundation instructions, Intel(R)
169 AVX-512 Conflict Detection instructions, Intel(R) AVX-512
170 Exponential and Reciprocal instructions, Intel(R) AVX-512
171 Prefetch instructions for Intel(R) processors, and the
172 instructions enabled with CORE-AVX2. Optimizes for Intel(R)
173 processors that support Intel(R) AVX-512 instructions.
174 CORE-AVX512
175 May generate Intel(R) Advanced Vector Extensions 512
176 (Intel(R) AVX-512) Foundation instructions, Intel(R)
177 AVX-512 Conflict Detection instructions, Intel(R) AVX-512
178 Doubleword and Quadword instructions, Intel(R) AVX-512
179 Byte and Word instructions and Intel(R) AVX-512 Vector
180 Length Extensions for Intel(R) processors, and the
181 instructions enabled with CORE-AVX2. Optimizes for Intel(R)
182 processors that support Intel(R) AVX-512 instructions.
183 COMMON-AVX512
184 May generate Intel(R) Advanced Vector Extensions 512
185 (Intel(R) AVX-512) Foundation instructions, Intel(R)
186 AVX-512 Conflict Detection instructions, as well as the
187 instructions enabled with CORE-AVX2. Optimizes for Intel(R)
188 processors that support Intel(R) AVX-512 instructions.
189
190-xHost generate instructions for the highest instruction set and processor
191 available on the compilation host machine
192
193-ax<code1>[,<code2>,...]
194 generate code specialized for processors specified by <codes>
195 while also generating generic IA-32 instructions.
196 <codes> includes one or more of the following:
197
198 SSE2 May generate Intel(R) SSE2 and SSE instructions for Intel
199 processors.
200 SSE3 May generate Intel(R) SSE3, SSE2, and SSE instructions for
201 Intel processors.
202
203 SSSE3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE
204 instructions for Intel processors.
205
206 SSE4.1 May generate Intel(R) SSE4.1, SSSE3, SSE3, SSE2, and SSE
207 instructions for Intel processors.
208
209 SSE4.2 May generate Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2,
210 and SSE instructions for Intel processors.
211 AVX May generate Intel(R) Advanced Vector Extensions (Intel(R)
212 AVX), Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3,
213 SSE2, and SSE instructions for Intel(R) processors.
214 CORE-AVX2
215 May generate Intel(R) Advanced Vector Extensions 2
216 (Intel(R) AVX2), Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3,
217 SSE2, and SSE instructions for Intel(R) processors.
218 CORE-AVX-I
219 May generate Intel(R) Advanced Vector Extensions (Intel(R)
220 AVX), including instructions in Intel(R) Core 2(TM)
221 processors in process technology smaller than 32nm,
222 Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
223 instructions for Intel(R) processors.
224 MIC-AVX512
225 May generate Intel(R) Advanced Vector Extensions 512
226 (Intel(R) AVX-512) Foundation instructions, Intel(R)
227 AVX-512 Conflict Detection instructions, Intel(R) AVX-512
228 Exponential and Reciprocal instructions, Intel(R) AVX-512
229 Prefetch instructions for Intel(R) processors, and the
230 instructions enabled with CORE-AVX2.
231 CORE-AVX512
232 May generate Intel(R) Advanced Vector Extensions 512
233 (Intel(R) AVX-512) Foundation instructions, Intel(R)
234 AVX-512 Conflict Detection instructions, Intel(R) AVX-512
235 Doubleword and Quadword instructions, Intel(R) AVX-512
236 Byte and Word instructions and Intel(R) AVX-512 Vector
237 Length Extensions for Intel(R) processors, and the
238 instructions enabled with CORE-AVX2.
239
240
241
242-mcpu=<cpu>
243 same as -mtune=<cpu>
244
245-mtune=<cpu>
246 optimize for a specific <cpu>
247 slm - processors that support Intel(R) SSE4.2 and MOVBE
248 instructions
249 core-avx2 - processors that support Intel(R) Advanced Vector
250 Extensions 2 (Intel(R) AVX2)
251 core-avx-i - processors that support Intel(R) Advanced Vector
252 Extensions (Intel(R) AVX), including instructions in
253 Intel(R) Core 2(TM) processors in process technology
254 smaller than 32nm
255 corei7-avx - processors that support Intel(R) Advanced Vector
256 Extensions (Intel(R) AVX)
257 corei7 - processors that support Intel(R) SSE4 Efficient
258 Accelerated String and Text Processing instructions
259 atom - processors that support MOVBE instructions
260 core2 - Intel(R) Core 2(TM) processor family
261 pentium-m - Intel(R) Pentium(R) M processors
262 pentium4 - Intel(R) Pentium(R) 4 processors
263 pentium3 - Intel(R) Pentium(R) III processors (Linux only)
264
265-march=<cpu>
266 generate code exclusively for a given <cpu>
267 slm - processors that support Intel(R) SSE4.2 and MOVBE
268 instructions
269 core-avx2 - processors that support Intel(R) Advanced Vector
270 Extensions 2 (Intel(R) AVX2)
271 core-avx-i - processors that support Intel(R) Advanced Vector
272 Extensions (Intel(R) AVX), including instructions in
273 Intel(R) Core 2(TM) processors in process technology
274 smaller than 32nm
275 corei7-avx - processors that support Intel(R) Advanced Vector
276 Extensions (Intel(R) AVX)
277 corei7 - processors that support Intel(R) SSE4 Efficient
278 Accelerated String and Text Processing instructions
279 atom - processors that support MOVBE instructions
280 core2 - Intel(R) Core 2(TM) processor family
281 pentium-m - Intel(R) Pentium(R) M processors
282 pentium4 - Intel(R) Pentium(R) 4 processors
283 pentium3 - Intel(R) Pentium(R) III processors (Linux only)
284
285-msse3 May generate Intel(R) SSE3, SSE2, and SSE instructions
286
287-mssse3 May generate Intel(R) SSSE3, SSE3, SSE2, and SSE instructions
288
289-msse4 Enable -msse4.2
290
291-msse4.1 May generate Intel(R) SSE4.1, SSSE3, SSE3, SSE2, and SSE instructions
292
293-msse4.2 May generate Intel(R) SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
294 instructions
295
296-mavx May generate Intel(R) AVX, SSE4.2, SSE4.1, SSSE3, SSE3, SSE2, and SSE
297 instructions
298
299-masm=<dialect>
300 generate asm instructions specified by <dialect>, which may be
301 att (DEFAULT) or intel
302
303-mmic build an application that runs natively on Intel(R) MIC Architecture
304
305-minstruction=<keyword>
306 Refine instruction set output for the selected target processor
307
308 [no]movbe - Do/do not generate MOVBE instructions with ATOM_SSSE3
309 (requires -xATOM_SSSE3)
310
311
312-f[no-]omit-frame-pointer
313 enable(DEFAULT)/disable use of EBP as general purpose register.
314 -fno-omit-frame-pointer replaces -fp
315
316-f[no-]exceptions
317 enable/disable exception handling table generation
318 The default for C++ is -fexceptions (enabled)
319 The default for C is -fno-exceptions (disabled)
320
321
322
323-f[no-]fat-lto-objects
324 enable/disable generation of true code/data when generating an
325 IL object using -ipo -c. Objects generated with -ffat-lto-objects
326 or -fno-fat-lto-objects are added unmodified to an archive when
327 using xiar. xiar behavior remains unchanged for an IL object
328 generated without specifying -f[no-]fat-lto-objects.
329
330-fnon-call-exceptions
331 enable/disable(DEFAULT) code that allows exceptions from trapping
332 instructions to be caught
333
334-regcall make __regcall the default calling convention
335
336-hotpatch[=n]
337 generate padding bytes for function entries to enable image
338 hotpatching. If specified, use 'n' as the padding.
339
340-fasynchronous-unwind-tables
341 determines whether unwind information is precise at an instruction
342 boundary or at a call boundary. -fno-asynchronous-unwind-tables is
343 the default for IA-32 architecture.
344
345-fextend-arguments=[32|64]
346 By default, unprototyped scalar integer arguments are passed
347 in 32-bits (sign-extended if necessary).
348 On Intel(R) 64, unprototyped scalar integer arguments may be
349 extended to 64-bits.
350
351-mgpu-arch=<arch>[,<arch>]
352 build offload code for graphics to run on a particular graphics
353 processor
354
355 ivybridge - May generate instructions for the graphics processor
356 that is on Intel(R) microarchitecture code name Ivy
357 Bridge.
358 haswell - May generate instructions for the graphics processor
359 that is on Intel(R) microarchitecture code name Haswell
360
361-mgpu-asm-dump[=<file>]
362 generate a native assembly listing for the processor graphics code
363 to be offloaded (Intel(R) Graphics Technology only)
364
365-m32 generate code for IA-32 architecture
366
367-m64 generate code for Intel(R) 64 architecture
368
369-m80387 Specify whether the compiler can use x87 instructions.
370 Use -mno-80387 to disable.
371
372-mx87 Same as -m80387
373
374-mstringop-strategy=<alg>
375 Override the internal decision heuristic for the particular algorithm
376 to use for inlining string operations. The allowed values for <alg>:
377 rep - Expand using i386 "rep" prefix (DEFAULT for -Os)
378 const_size_loop - Expand into an inline loop when size is known at
379 compile time (DEFAULT)
380 libcall - Always use a library call.
381
382-mstringop-inline-threshold=<val>
383 inline calls to memcall-like (memcpy, memset) functions when the
384 number of bytes the functions handle are known at compile time and
385 less than <val>
386
387
388Interprocedural Optimization (IPO)
389----------------------------------
390
391
392
393-[no-]ip enable(DEFAULT)/disable single-file IP optimization
394 within files
395
396-ipo[n] enable multi-file IP optimization between files
397
398-ipo-c generate a multi-file object file (ipo_out.o)
399
400-ipo-S generate a multi-file assembly file (ipo_out.S)
401
402-ip-no-inlining
403 disable full and partial inlining
404
405-ip-no-pinlining
406 disable partial inlining
407
408-ipo-separate
409 create one object file for every source file (overrides -ipo[n])
410
411-ipo-jobs<n>
412 specify the number of jobs to be executed simultaneously during the
413 IPO link phase
414
415
416Advanced Optimizations
417----------------------
418
419
420
421-unroll[n]
422 set maximum number of times to unroll loops. Omit n to use default
423 heuristics. Use n=0 to disable the loop unroller
424
425-[no-]unroll-aggressive
426 enables more aggressive unrolling heuristics
427
428-funroll-loops
429 unroll loops based on default heuristics
430
431-[no-]scalar-rep
432 enable(DEFAULT)/disable scalar replacement (requires -O3)
433
434-[no-]ansi-alias
435 enable(DEFAULT)/disable use of ANSI aliasing rules optimizations;
436 user asserts that the program adheres to these rules
437
438-[no-]ansi-alias-check
439 enable(DEFAULT)/disable ANSI alias checking when using -ansi-alias
440
441-[no-]complex-limited-range
442 enable/disable(DEFAULT) the use of the basic algebraic expansions of
443 some complex arithmetic operations. This can allow for some
444 performance improvement in programs which use a lot of complex
445 arithmetic at the loss of some exponent range.
446
447-[no-]alias-const
448 enable/disable(DEFAULT) a heuristic stating that if two arguments to
449 a function have pointer type, a pointer to const does not alias a
450 pointer to non-const. Also known as the input/output buffer rule, it
451 assumes that input and output buffer arguments do not overlap.
452
453-fargument-alias
454 arguments may alias each other and may alias global storage
455
456-fargument-noalias
457 arguments do not alias each other but may alias global storage
458
459-fargument-noalias-global
460 arguments do not alias each other and do not alias global storage
461
462-ftls-model=<model>
463 change thread-local storage model, where <model> can be the
464 following: global-dynamic, local-dynamic, initial-exec or local-exec
465
466-q[no-]opt-multi-version-aggressive
467 enables more aggressive multi-versioning to check for pointer
468 aliasing and scalar replacement
469
470-qopt-ra-region-strategy[=<keyword>]
471 select the method that the register allocator uses to partition each
472 routine into regions
473 routine - one region per routine
474 block - one region per block
475 trace - one region per trace
476 loop - one region per loop
477 default - compiler selects best option
478
479-[no-]vec
480 enables(DEFAULT)/disables vectorization
481
482-[no-]vec-guard-write
483 enables cache/bandwidth optimization for stores under conditionals
484 within vector loops
485
486-vec-threshold[n]
487 sets a threshold for the vectorization of loops based on the
488 probability of profitable execution of the vectorized loop in
489 parallel
490
491-vecabi=<arg>
492 select vector function ABI
493 legacy - use the legacy vector function ABI
494 compat - use the compatibility vector function ABI (DEFAULT)
495
496-qopt-malloc-options={0|1|2|3|4}
497 specify malloc configuration parameters. Specifying a non-zero <n>
498 value will cause alternate configuration parameters to be set for
499 how malloc allocates and frees memory
500
501-qopt-calloc
502 enable/disable(DEFAULT) calls to fast calloc function
503
504-qopt-jump-tables=<arg>
505 control the generation of jump tables
506 default - let the compiler decide when a jump table, a series of
507 if-then-else constructs or a combination is generated
508 large - generate jump tables up to a certain pre-defined size
509 (64K entries)
510 <n> - generate jump tables up to <n> in size
511 use -qno-opt-jump-tables to lower switch statements as chains of
512 if-then-else constructs
513
514-fno-jump-tables
515 do not generate jump tables for switches and if-then-else statements
516
517-qopt-block-factor=<n>
518 specify blocking factor for loop blocking
519
520-ffreestanding
521 compile in a freestanding environment where the standard library
522 may not be present
523
524-qopt-streaming-stores=<arg>
525 specifies whether streaming stores are generated
526 always - enables generation of streaming stores under the
527 assumption that the application is memory bound
528 auto - compiler decides when streaming stores are used (DEFAULT)
529 never - disables generation of streaming stores
530
531-ipp[=<arg>]
532 link some or all of the Intel(R) Integrated Performance Primitives
533 (Intel(R) IPP) libraries and bring in the associated headers
534 common - link using the main libraries set. This is the
535 default value when -ipp is specified
536 crypto - link using the main libraries set and the crypto
537 library
538
539
540
541-ipp-link=<arg>
542 choose whether to link with static or dynamic libraries to support
543 Intel(R) Integrated Performance Primitives (Intel(R) IPP)
544 dynamic - link using the dynamic libraries set. This is the
545 default value when -ipp is specified on Windows
546 static - link using the static libraries set. This is the
547 default value when -ipp is specified on Linux
548
549
550
551 nonpic - link using the version of the libraries that do not
552 have position independent code
553 nonpic_crypto - link using the crypto library and the version of
554 the libraries that do not have position independent
555 code
556
557-mkl[=<arg>]
558 link to the Intel(R) Math Kernel Library (Intel(R) MKL) and bring
559 in the associated headers
560 parallel - link using the threaded Intel(R) MKL libraries. This
561 is the default when -mkl is specified
562 sequential - link using the non-threaded Intel(R) MKL libraries
563
564 cluster - link using the Intel(R) MKL Cluster libraries plus
565 the sequential Intel(R) MKL libraries
566
567-tbb link to the Intel(R) Threading Building Blocks (Intel(R) TBB)
568 libraries and bring in the associated headers
569
570-daal[=<arg>]
571 link to the Intel(R) Data Analytics Acceleration Library (Intel(R)
572 DAAL) libraries and bring in the associated headers
573 parallel - link using the threaded Intel(R) DAAL (DEFAULT)
574 sequential - link using the non-threaded Intel(R) DAAL
575
576-q[no-]opt-subscript-in-range
577 assumes no overflows in the intermediate computation of the
578 subscripts
579
580-[no-]use-intel-optimized-headers
581 take advantage of the optimized header files
582
583-cilk-serialize
584 run a Cilk program as a C/C++ serialized program
585
586-[no-]intel-extensions
587 enable(DEFAULT)/disable C/C++ language extensions such as array
588 notation, Intel(R) Cilk(TM) Plus language extensions, and
589 support for decimal floating-point types.
590
591-q[no-]opt-matmul
592 replace matrix multiplication with calls to intrinsics and threading
593 libraries for improved performance (DEFAULT at -O3 -parallel)
594
595-[no-]simd
596 enables(DEFAULT)/disables vectorization using simd pragma
597
598-guide-opts=<arg>
599 tells the compiler to analyze certain code and generate
600 recommendations that may improve optimizations
601
602-guide-file[=<filename>]
603 causes the results of guide to be output to a file
604
605-guide-file-append[=<filename>]
606 causes the results of guide to be appended to a file
607
608-guide[=<level>]
609 lets you set a level (1 - 4) of guidance for auto-vectorization,
610 auto-parallelization, and data transformation (DEFAULT is 4 when the
611 option is specified)
612
613-guide-data-trans[=<level>]
614 lets you set a level (1 - 4) of guidance for data transformation
615 (DEFAULT is 4 when the option is specified)
616
617-guide-par[=<level>]
618 lets you set a level (1 - 4) of guidance for auto-parallelization
619 (DEFAULT is 4 when the option is specified)
620
621-guide-par[=<level>]
622 lets you set a level (1 - 3) of guidance for auto-parallelization
623 (DEFAULT is 2 when the option is specified)
624
625-guide-vec[=<level>]
626 lets you set a level (1 - 4) of guidance for auto-vectorization
627 (DEFAULT is 4 when the option is specified)
628
629-guide-profile=<[file|dir]>[,[file|dir],...]
630 specify a loop profiler data file (or set of files in a directory)
631 when using the -guide option
632
633-qopt-mem-layout-trans[=<level>]
634 controls the level of memory layout transformations performed by the
635 compiler
636 0 - disable memory layout transformations (same as
637 -qno-opt-mem-layout-trans)
638 1 - enable basic memory layout transformations
639 2 - enable more memory layout transformations (DEFAULT when the
640 option is specified)
641 3 - enable aggressive memory layout transformations
642
643-qopt-prefetch[=n]
644 enable levels of prefetch insertion, where 0 disables.
645 n may be 0 through 4 inclusive. Default is 2.
646
647-qno-opt-prefetch
648 disable(DEFAULT) prefetch insertion. Equivalent to -qopt-prefetch=0
649
650-qopt-prefetch-distance=n1[,n2]
651 specify the prefetch distance (how many iterations ahead, use n1 and
652 n2 values such that n1>=n2) to be used for compiler generated
653 prefetches inside loops. n1 indicates distance from memory to L2
654 cache and n2 indicates distance from L2 to L1. (Intel(R) MIC
655 Architecture specific)
656
657-qopt-prefetch-issue-excl-hint
658 generates PrefetchW instruction for Intel(R) microarchitecture
659 code name Broadwell processors and beyond when -qopt-prefetch
660 is also used
661
662-qopt-threads-per-core=n
663 specifies the number of threads (1 - 4) per core to be used for an
664 application (Intel(R) MIC Architecture specific)
665
666-qopt-streaming-cache-evict=n
667 specifies the cache line eviction level (0 - 3) when streaming
668 loads/stores are used. (Intel(R) MIC Architecture specific)
669
670-qopt-gather-scatter-unroll=n
671 specify an alternative loop unroll sequence for gather and scatter
672 loops (Intel(R) MIC Architecture specific). Disable with
673 -qno-opt-gather-scatter-unroll (equivalent to n=0)
674
675-qopt-dynamic-align
676 enable(DEFAULT) dynamic data alignment optimizations. Specify
677 -qno-opt-dynamic-align to disable
678
679
680Profile Guided Optimization (PGO)
681---------------------------------
682
683
684
685-prof-dir <dir>
686 specify directory for profiling output files (*.dyn and *.dpi)
687
688-prof-src-root <dir>
689 specify project root directory for application source files to
690 enable relative path resolution during profile feedback on sources
691 below that directory
692
693-prof-src-root-cwd
694 specify the current directory as the project root directory for
695 application source files to enable relative path resolution during
696 profile feedback on sources below that directory
697
698-[no-]prof-src-dir
699 specify whether directory names of sources should be
700 considered when looking up profile records within the .dpi file
701
702-prof-file <file>
703 specify file name for profiling summary file
704
705-[no-]prof-data-order
706 enable/disable(DEFAULT) static data ordering with profiling
707
708-[no-]prof-func-order
709 enable/disable(DEFAULT) function ordering with profiling
710
711-[no-]prof-func-groups
712 enable(DEFAULT with PGO)/disable function grouping
713
714-prof-gen[=keyword[,keyword]]
715 instrument program for profiling. Optional keywords are as follows.
716 default - Produces an instrumented object file. This is the same
717 as specifying the -prof-gen option with no keyword.
718 srcpos - Produces an instrumented object file and information
719 needed for using the code coverage tool.
720 globdata - Produces an instrumented object file that includes
721 information for global data layout.
722 threadsafe - Collects PGO data with guards for threaded
723 applications.
724
725-no-prof-gen
726 disable profiling instrumentation
727
728-prof-use[=<arg>]
729 enable use of profiling information during optimization
730 weighted - invokes profmerge with -weighted option to scale data
731 based on run durations
732 [no]merge - enable(default)/disable the invocation of the profmerge
733 tool
734
735-no-prof-use
736 disable use of profiling information during optimization
737
738-fnsplit[=<n>]
739 enable function splitting (enabled with /Qprof-use for IA-32 Windows)
740 n - positive integer indicating the threshold number. The blocks
741 can be placed into a different code segment if their
742 execution probability is less than the specified value of
743 range 0 <= n <= 100
744 use -no-fnsplit to disable
745
746-p compile and link for function profiling with UNIX gprof tool
747 On IA32 and Intel(r)64, -pg is also valid
748
749-f[no-]instrument-functions
750 determine whether function entry and exit points are instrumented
751
752-prof-hotness-threshold=<val>
753 set the hotness threshold for function grouping and function ordering
754 val indicates percentage of functions to be placed in hot region.
755 This option requires -prof-use
756 and -prof-func-groups or -prof-func-order
757
758
759-prof-value-profiling=<arg>[,<arg>,...]
760 limit value profiling
761 none - inhibit all types of value profiling
762 nodivide - inhibit value profiling of non-compile time constants
763 used in division or remainder operations
764 noindcall - inhibit value profiling of function addresses at
765 indirect call sites
766
767-profile-functions
768 enable instrumentation in generated code for collecting
769 function execution time profiles
770
771-profile-loops=<arg>
772 enable instrumentation in generated code for collecting
773 loop execution time profiles
774 inner - instrument inner loops
775 outer - instrument outer loops
776 all - instrument all loops
777
778-profile-loops-report=<arg>
779 Control the level of instrumentation inserted for reporting loop
780 execution profiles
781 1 - report loop times
782 2 - report loop times and iteration counts
783
784-prof-gen-sampling
785 prepares application executables for hardware profiling (sampling)
786 and causes the compiler to generate source code mapping information
787
788-prof-use-sampling=file[:file:...]
789 enable use of hardware profiling (sampling) information during
790 optimization. Argument provides list of one or more Intel(R) VTune
791 report files (created with the VTune report named .pgo-input.) to
792 use for input data
793
794
795Optimization Reports
796--------------------
797
798
799
800-vec-report[=n]
801 control amount of vectorizer diagnostic information
802 n=0 no diagnostic information
803 n=1 indicate vectorized loops (DEFAULT when enabled)
804 n=2 indicate vectorized/non-vectorized loops
805 n=3 indicate vectorized/non-vectorized loops and prohibiting
806 data dependence information
807 n=4 indicate non-vectorized loops
808 n=5 indicate non-vectorized loops and prohibiting data
809 dependence information
810 n=6 indicate vectorized/non-vectorized loops with greater
811 details and prohibiting data dependence information
812 n=7 indicate vector code quality message ids and data values
813 for vectorized loops
814
815-qopt-report[=n]
816 generate an optimization report. Default destination is
817 <target>.optrpt. Levels of 0 - 5 are valid.
818 Please see documentation for additional details of
819 information provided by phase per level.
820 0 disable optimization report output
821 2 DEFAULT when enabled
822
823-qopt-report-file=[stdout | stderr | <file>]
824 specify the filename or output stream for the generated report
825
826-qopt-report-stdout
827 specify the generated report should be directed to stdout
828
829-qopt-report-per-object
830 specify the generated report should be directed to a .optrpt file
831 in the output directory (DEFAULT when another destination for the
832 report is not specified)
833
834-qopt-report-phase=<phase>[,<phase>,...]
835 specify one or more phases that reports are generated against
836
837-qopt-report-routine=<name>[,<name>,...]
838 restrict the report to routines containing the given name
839
840-qopt-report-filter=<string>
841 restricts the opt-report to specific files, routines or line
842 number ranges. Refer to the documentation for the specific
843 syntax of parameter string.
844
845-qopt-report-format=[text|vs]
846 specify the output format to be used for the opt-report as either
847 plain text or a format for use in the Microsoft* Visual Studio IDE
848
849-q[no-]opt-report-embed
850 When enabled, if an assembly file is being generated, special loop
851 info annotations will be emitted in the assembly file. If an object
852 file/executable is being generated, these will be emitted into the
853 object file/executable for use by the Intel VTune Amplifier
854 application. Automatically enabled when symbolic debug information
855 is enabled.
856
857-qopt-report-help
858 display the optimization phases available for reporting
859
860-qopt-report-names=<keyword>
861 Specifies whether mangled or unmangled names should appear in the
862 optimization report.
863 mangled - use mangled names
864 unmangled - use unmangled names (DEFAULT)
865
866-tcollect[=<lib>]
867 inserts instrumentation probes calling the Intel(R) Trace Collector
868 API. The library -l<lib> is linked in the default being -lVT
869 (requires Intel(R) Trace Collector)
870
871-tcollect-filter file
872 Enable or disable the instrumentation of specified functions.
873 (requires Intel(R) Trace Collector)
874
875
876OpenMP* and Parallel Processing
877------------------------------
878
879
880
881-qopenmp enable the compiler to generate multi-threaded code based on the
882 OpenMP* directives (same as -fopenmp)
883 Use -qno-openmp to disable
884
885-qopenmp-stubs
886 enables the user to compile OpenMP programs in sequential mode. The
887 OpenMP directives are ignored and a stub OpenMP library is linked
888 (sequential)
889
890-qopenmp-report{0|1|2}
891 control the OpenMP parallelizer diagnostic level
892
893-qopenmp-lib=<ver>
894 choose which OpenMP library version to link with
895 compat - use the GNU compatible OpenMP run-time libraries
896 (DEFAULT)
897
898-qopenmp-link=<library>
899 choose whether to link with the static or dynamic OpenMP
900 libraries. Default is dynamic.
901
902-qopenmp-task=<arg>
903 choose which OpenMP tasking model to support
904 omp - support OpenMP 3.0 tasking (DEFAULT)
905 intel - support Intel taskqueuing
906
907-qopenmp-threadprivate=<ver>
908 choose which threadprivate implementation to use
909 compat - use the GNU compatible thread local storage
910 legacy - use the Intel compatible implementation
911 (DEFAULT)
912
913-parallel
914 enable the auto-parallelizer to generate multi-threaded code for
915 loops that can be safely executed in parallel
916
917-par-report[=n]
918 control the auto-parallelizer diagnostic level (n=0,1,2,3)
919
920-par-threshold[n]
921 set threshold for the auto-parallelization of loops where n is an
922 integer from 0 to 100
923
924-par-runtime-control[n]
925 Control parallelizer to generate runtime check code for effective
926 automatic parallelization.
927 n=0 no runtime check based auto-parallelization
928 n=1 generate runtime check code under conservative mode
929 (DEFAULT when enabled)
930 n=2 generate runtime check code under heuristic mode
931 n=3 generate runtime check code under aggressive mode
932
933-par-schedule-static[=n]
934 Specifies a scheduling algorithm for DO loop iteration.
935 Divides iterations into contiguous pieces. Size n if
936 specified, equal sized pieces if not.
937
938-par-schedule-static-balanced[=n]
939 Divides iterations into even-sized chunks. Size n if
940 specified, equal sized pieces if not.
941
942-par-schedule-static-steal[=n]
943 Divides iterations into even-sized chunks, but allows
944 threads to steal parts of chunks from neighboring threads
945
946-par-schedule-dynamic[=n]
947 Specifies a scheduling algorithm for DO loop iteration.
948 Assigns iterations to threads in chunks dynamically.
949 Chunk size is n iterations if specified, otherwise 1.
950
951-par-schedule-guided[=n]
952 Specifies a scheduling algorithm for DO loop iteration.
953 Indicates a minimum number of iterations. If specified,
954 n is the minimum number, otherwise 1.
955
956-par-schedule-guided-analytical[=n]
957 Divides iterations by using exponential distribution or
958 dynamic distributions.
959
960-par-schedule-runtime
961 Specifies a scheduling algorithm for DO loop iteration.
962 Defers the scheduling decision until runtime.
963
964-par-schedule-auto
965 Lets the compiler or run-time system determine the
966 scheduling algorithm.
967
968-par-affinity=[<modifier>,...]<type>[,<permute>][,<offset>]
969 tune application performance by setting different thread affinity
970
971-par-num-threads=<n>
972 tune application performance by setting different number of threads
973
974-parallel-source-info[=n]
975 enable(DEFAULT)/disable the emission of source location information
976 for parallel code generation with OpenMP and auto-parallelization
977 0 - disable (same as -no-parallel-source-info)
978 1 - emit routine name and line information (DEFAULT)
979 2 - emit path, file, routine name and line information
980
981-qopenmp-simd
982 Enables OpenMP* SIMD compilation. Enabled by default with
983 -qopenmp. Use -qno-openmp-simd to disable.
984
985-qopenmp-offload[=<kind>]
986 Enables OpenMP* offloading compilation for target pragmas. This
987 option only applies to Intel(R) MIC Architecture and Intel(R)
988 Graphics Technology. Enabled by default with -qopenmp.
989 Use -qno-openmp-offload to disable.
990 Specify kind to specify the default device for target pragmas
991 host - allow target code to run on host system while still doing
992 the outlining for offload
993 mic - specify Intel(R) MIC Architecture
994 gfx - specify Intel(R) Graphics Technology
995
996-f[no-]mpc_privatize
997 Enables privatization of all static data for the MPC
998 unified parallel runtime. This will cause calls to
999 extended thread local storage resolution run-time routines
1000 which are not supported on standard linux distributions.
1001 This option is only usable in conjunction with the MPC
1002 unified parallel runtime. The default is -fno-mpc-privatize.
1003
1004
1005Floating Point
1006--------------
1007
1008
1009
1010-fp-model <name>
1011 enable <name> floating point model variation
1012 [no-]except - enable/disable floating point exception semantics
1013 fast[=1|2] - enables more aggressive floating point optimizations
1014 precise - allows value-safe optimizations
1015 source - enables intermediates in source precision
1016 sets -assume protect_parens for Fortran
1017 strict - enables -fp-model precise -fp-model except, disables
1018 contractions and enables pragma stdc fenv_access
1019
1020 double - rounds intermediates in 53-bit (double) precision
1021 extended - rounds intermediates in 64-bit (extended) precision
1022
1023-fp-speculation=<mode>
1024 enable floating point speculations with the following <mode>
1025 conditions:
1026 fast - speculate floating point operations (DEFAULT)
1027 safe - speculate only when safe
1028 strict - same as off
1029 off - disables speculation of floating-point operations
1030
1031-pc32 set internal FPU precision to 24 bit significand
1032
1033-pc64 set internal FPU precision to 53 bit significand
1034
1035-pc80 set internal FPU precision to 64 bit significand (DEFAULT)
1036
1037-mp1 improve floating-point precision
1038
1039-mieee-fp
1040 maintain floating point precision (disables some optimizations)
1041 can be disabled with -mno-ieee-fp
1042
1043-[no-]prec-sqrt
1044 determine if certain square root optimizations are enabled
1045
1046-[no-]prec-div
1047 improve precision of FP divides (some speed impact)
1048
1049-[no-]fast-transcendentals
1050 generate a faster version of the transcendental functions
1051
1052-[no-]fp-port
1053 round fp results at assignments and casts (some speed impact)
1054
1055-fp-stack-check
1056 enable fp stack checking after every function/procedure call
1057
1058-rcd rounding mode to enable fast float-to-int conversions
1059
1060-[no-]ftz
1061 enable/disable flush denormal results to zero
1062
1063-[no-]fma
1064 enable/disable the combining of floating point multiplies and
1065 add/subtract operations
1066
1067-fp-trap=<arg>[,<arg>,...]
1068 control floating point traps at program start. <arg> can be of the
1069 following values
1070 [no]divzero - [Do not] trap on division by zero
1071 [no]inexact - [Do not] trap on inexact result
1072 [no]invalid - [Do not] trap on invalid operation
1073 [no]overflow - [Do not] trap on overflow
1074 [no]underflow - [Do not] trap on underflow
1075 [no]denormal - [Do not] trap on denormal
1076 all - enable trap on all of the above
1077 none - trap on none of the above
1078 common - trap on most commonly used IEEE traps
1079 (invalid, division by zero, overflow)
1080
1081-fp-trap-all=<arg>[,<arg>,...]
1082 control floating point traps in every routine. <arg> can be of the
1083 values specified in -fp-trap
1084
1085-fimf-absolute-error=value[:funclist]
1086 define the maximum allowable absolute error for math library
1087 function results
1088 value - a positive, floating-point number conforming to the
1089 format [digits][.digits][{e|E}[sign]digits]
1090 funclist - optional comma separated list of one or more math
1091 library functions to which the attribute should be
1092 applied
1093
1094-fimf-accuracy-bits=bits[:funclist]
1095 define the relative error, measured by the number of correct bits,
1096 for math library function results
1097 bits - a positive, floating-point number
1098 funclist - optional comma separated list of one or more math
1099 library functions to which the attribute should be
1100 applied
1101
1102-fimf-arch-consistency=value[:funclist]
1103 ensures that the math library functions produce consistent results
1104 across different implementations of the same architecture
1105 value - true or false
1106 funclist - optional comma separated list of one or more math
1107 library functions to which the attribute should be
1108 applied
1109
1110-fimf-max-error=ulps[:funclist]
1111 defines the maximum allowable relative error, measured in ulps, for
1112 math library function results
1113 ulps - a positive, floating-point number conforming to the
1114 format [digits][.digits][{e|E}[sign]digits]
1115 funclist - optional comma separated list of one or more math
1116 library functions to which the attribute should be
1117 applied
1118
1119-fimf-precision=value[:funclist]
1120 defines the accuracy (precision) for math library functions
1121 value - defined as one of the following values
1122 high - equivalent to max-error = 0.6
1123 medium - equivalent to max-error = 4 (DEFAULT)
1124 low - equivalent to accuracy-bits = 11 (single
1125 precision); accuracy-bits = 26 (double
1126 precision)
1127 funclist - optional comma separated list of one or more math
1128 library functions to which the attribute should be
1129 applied
1130
1131-fimf-domain-exclusion=classlist[:funclist]
1132 indicates the input arguments domain on which math functions
1133 must provide correct results.
1134 classlist - defined as one of the following values
1135 nans, infinities, denormals, zeros
1136 all, none, common
1137 funclist - optional list of one or more math library
1138 functions to which the attribute should be applied.
1139
1140
1141
1142
1143Inlining
1144--------
1145
1146
1147
1148-inline-level=<n>
1149 control inline expansion:
1150 n=0 disable inlining
1151 n=1 inline functions declared with __inline, and perform C++
1152 inlining
1153 n=2 inline any function, at the compiler's discretion
1154
1155-f[no-]inline
1156 inline functions declared with __inline, and perform C++ inlining
1157
1158-f[no-]inline-functions
1159 inline any function at the compiler's discretion
1160
1161-finline-limit=<n>
1162 set maximum number of statements a function can have and still be
1163 considered for inlining
1164
1165-fgnu89-inline
1166 use C89 semantics for "inline" functions when in C99 mode
1167
1168-inline-min-size=<n>
1169 set size limit for inlining small routines
1170
1171-no-inline-min-size
1172 no size limit for inlining small routines
1173
1174-inline-max-size=<n>
1175 set size limit for inlining large routines
1176
1177-no-inline-max-size
1178 no size limit for inlining large routines
1179
1180-inline-max-total-size=<n>
1181 maximum increase in size for inline function expansion
1182
1183-no-inline-max-total-size
1184 no size limit for inline function expansion
1185
1186-inline-max-per-routine=<n>
1187 maximum number of inline instances in any function
1188
1189-no-inline-max-per-routine
1190 no maximum number of inline instances in any function
1191
1192-inline-max-per-compile=<n>
1193 maximum number of inline instances in the current compilation
1194
1195-no-inline-max-per-compile
1196 no maximum number of inline instances in the current compilation
1197
1198-inline-factor=<n>
1199 set inlining upper limits by n percentage
1200
1201-no-inline-factor
1202 do not set set inlining upper limits
1203
1204-inline-forceinline
1205 treat inline routines as forceinline
1206
1207-inline-calloc
1208 directs the compiler to inline calloc() calls as malloc()/memset()
1209
1210-inline-min_caller-growth=<n>
1211 set lower limit on caller growth due to inlining a single routine
1212
1213-no-inline-min-caller-growth
1214 no lower limit on caller growth due to inlining a single routine
1215
1216
1217Output, Debug, PCH
1218------------------
1219
1220
1221
1222-c compile to object (.o) only, do not link
1223
1224-S compile to assembly (.s) only, do not link
1225
1226-fsource-asm
1227 produce assembly file with optional source annotations (requires -S)
1228
1229-f[no-]verbose-asm
1230 produce assembly file with compiler comments (DEFAULT) (requires -S)
1231
1232-fcode-asm
1233 produce assembly file with optional code annotations (requires -S)
1234
1235-use-msasm
1236 support Microsoft* style assembly language insertion using MASM style
1237 syntax
1238
1239-fasm-blocks
1240 enables the use of blocks and entire functions of assembly code
1241 within a C or C++ file
1242
1243-Fa[file]
1244 name assembly file (or directory for multiple files; i.e. /FaMYDIR)
1245
1246-Fo[file]
1247 name object file (or directory for multiple files; i.e. /FoMYDIR)
1248
1249-o <file>
1250 name output file
1251
1252-g[level]
1253 Produce symbolic debug information.
1254 Valid [level] values:
1255 0 - Disable generation of symbolic debug information.
1256 1 - Emit minimal debug information for performing stack traces.
1257 2 - Emit complete debug information. (default for -g)
1258 3 - Emit extra information which may be useful for some tools.
1259
1260-gdwarf-<version>
1261 Enable generation of debug information using the specified DWARF
1262 version. These options may require additional tools such as linkers
1263 and debuggers which support these formats.
1264 Valid <version> values:
1265 2 - DWARF Debug Information Format Version 2.
1266 3 - DWARF Debug Information Format Version 3. (default for -g)
1267 4 - DWARF Debug Information Format Version 4.
1268
1269-gsplit-dwarf
1270 Generates an additional output file containing most of the debug
1271 information. This reduces the size of objects processed by the
1272 linker. The additional output file will be given a .dwo file
1273 extension. This option may require additional tools which support
1274 DWARF object files.
1275
1276-debug [keyword]
1277 Control the emission of debug information.
1278 Valid [keyword] values:
1279 none
1280 Disables debug generation.
1281
1282 all, full (default if no keyword was specified)
1283 Generates complete debug information.
1284
1285 minimal
1286 Generates line number information.
1287
1288 extended
1289 Generates complete debug information with semantic stepping
1290 and variable locations enabled.
1291
1292 [no]variable-locations
1293 Controls additional debug information useful for tracking
1294 variable values in optimized code.
1295
1296 [no]semantic-stepping
1297 Controls additional debug information useful for stepping
1298 through optimized code.
1299
1300 [no]pubnames
1301 Controls generation of the DWARF .debug_pubnames section.
1302
1303 [no]emit-column
1304 Controls additional line number information with columns.
1305
1306 [no]inline-debug-info
1307 Controls additional debug information for inlined code.
1308
1309 [no]expr-source-pos
1310 Controls output of source positions for expressions.
1311
1312 [no]macros
1313 Controls output of debug information for preprocessor macros.
1314
1315 parallel
1316 Emit code instrumentation useful for thread data sharing and
1317 reentrant call detection.
1318
1319-fvar-tracking
1320 Same as "-debug variable-locations".
1321
1322-fvar-tracking-assignments
1323 Same as "-debug semantic-stepping".
1324
1325-f[no-]dwarf2-cfi-asm
1326 Control whether the compiler should generate CFI directives which
1327 the assembler can use to generate unwind information, or if the
1328 compiler should emit the unwind information directly.
1329
1330-grecord-gcc-switches
1331 Record command line options in the DW_AT_producer attribute in
1332 the DWARF debugging information.
1333
1334-fno-merge-debug-strings
1335 Do not merge identical debug strings in different object files.
1336
1337-fno-merge-constants
1338 Do not merge identical string constants in different object files.
1339
1340-ftrapuv trap uninitialized variables
1341
1342-map-opts
1343 enable option mapping tool
1344
1345-print-multi-lib
1346 print information about libraries being used
1347
1348-pch-create <file>
1349 create precompiled header file
1350
1351-pch-use <file>
1352 use precompiled header file
1353
1354-pch enable automatic precompiled header file creation/usage
1355
1356-pch-dir <dir>
1357 name precompiled header directory
1358
1359-check-pointers=<arg>
1360 Specifies what type of bounds checking occurs. Possible values are:
1361 none - Disables bounds checking. This is the default.
1362 rw - Checks bounds for reads and writes through pointers.
1363 write - Checks bounds for writes through pointers only.
1364 This switch is only valid with Intel(R) Parallel Studio XE
1365
1366-check-pointers-mpx=<arg>
1367 Enables bounds checking using Intel(R) MPX support. Possible
1368 values are:
1369 none - Disables bounds checking. This is the default.
1370 rw - Checks bounds for reads and writes through pointers.
1371 write - Checks bounds for writes through pointers only.
1372 This switch is only valid with Intel(R) Parallel Studio XE and on
1373 targets with Intel(R) MPX support.
1374
1375-check-pointers-dangling=<arg>
1376 Specifies what type of dangling pointer checking occurs. Possible
1377 values are:
1378 none - Disables dangling pointer checking. This is the default.
1379 heap - Check dangling references on heap.
1380 stack - Check dangling references on stack.
1381 all - Check dangling references on both heap and stack.
1382 This switch is only valid with Intel(R) Parallel Studio XE
1383
1384-[no-]check-pointers-undimensioned
1385 Bounds checking occurs for memory access through arrays that are
1386 declared without dimensions. This checking occurs for both
1387 dimensioned and undimensioned arrays.
1388 This switch is only valid with Intel(R) Parallel Studio XE
1389
1390-[no-]check-pointers-narrowing
1391 When this is disabled, Pointer Checker will not give an error when
1392 pointers to a structure field are moved to fields in the same
1393 structure.
1394 This switch is only valid with Intel(R) Parallel Studio XE
1395
1396-f[no-]emit-class-debug-always
1397 Emit debug information for a C++ class into each object file where
1398 the class is used. This flag is useful for tools which are unable
1399 to resolve incomplete type descriptions. Using this option may
1400 cause a large increase in the size of the debug information.
1401
1402-f[no-]eliminate-unused-debug-types
1403 When disabled, debug information for all types present in the
1404 sources will be emitted. Using this option may cause a large
1405 increase in the size of the debug information.
1406
1407-qemit-build-options
1408 Output the options used during the compilation to a corresponding
1409 .dashboard file. This file is to be consumed by the dbmerge tool
1410 and used by the dashboard tool.
1411
1412-qemit-messages
1413 Output the diagnostics emitted during the compilation to a
1414 corresponding .dashboard file. This file is to be consumed by the
1415 dbmerge tool and used by the dashboard tool.
1416
1417
1418Preprocessor
1419------------
1420
1421
1422
1423-A<name>[<val>]
1424 create an assertion <name> having value <val>
1425
1426-C do not strip comments
1427
1428-D<name>[=<text>]
1429 define macro
1430
1431-U<name> remove predefined macro
1432
1433-E preprocess to stdout
1434
1435-EP preprocess to stdout, omitting #line directives
1436
1437-P preprocess to file, omitting #line directives
1438
1439-I<dir> add directory to include file search path
1440
1441-idirafter<dir>
1442 add directory to the second include file search path (after -I)
1443
1444-isystem<dir>
1445 add directory to the start of the system include path
1446
1447-X, -nostdinc
1448 remove standard directories from include file search path
1449
1450-nostdinc++
1451 remove standard C++ directories from include file search path
1452
1453-iprefix <prefix>
1454 use <prefix> with -iwithprefix as a prefix
1455
1456-iwithprefix <dir>
1457 append <dir> to the prefix passed in by -iprefix and put it on the
1458 include search path at the end of the include directories
1459
1460-iwithprefixbefore <dir>
1461 similar to -iwithprefix except the include directory is placed in the
1462 same place as -I command line include directories
1463
1464-iquote <dir>
1465 add directory to the front of the include file search path for files
1466 included with quotes, but not brackets
1467
1468-imacros <file>
1469 treat <file> as an #include file, but throw away all preprocessing
1470 while macros defined remain defined
1471
1472-H print include file order
1473
1474-B<prefix>
1475 find libraries, headers and executables in <prefix>
1476
1477-M generate makefile dependency information
1478
1479-MM similar to -M, but do not include system header files
1480
1481-MG similar to -M, but treat missing header files as generated files
1482
1483-MD preprocess and compile, generating output file containing dependency
1484 information ending with extension .d
1485
1486-MMD similar to -MD, but do not include system header files
1487
1488-MF<file>
1489 generate makefile dependency information in file (must specify -M
1490 or -MM)
1491
1492-MP add a phony target for each dependency
1493
1494-MT<target>
1495 change the default target rule for dependency generation
1496
1497-MQ<target>
1498 same as -MT, but quotes special Make characters
1499
1500-dM output macro definitions in effect after preprocessing (use with -E)
1501
1502-dD same as -dM, but output #define directives in preprocessed source
1503
1504-dN same as -dD, but #define directives contain only macro names
1505
1506-gcc Predefine the "__GNUC__", "__GNUC_MINOR__", and
1507 "__GNUC_PATCHLEVEL__" macros (DEFAULT)
1508
1509-no-gcc Do not predefine GNUC macros listed in -gcc mode. Warning: can
1510 prevent correct system header compilation, see -gcc-sys
1511
1512-gcc-sys same as -no-gcc, except that the GNU macros are defined only while
1513 preprocessing the system include headers
1514
1515-no-icc do not predefine the "__ICC" and "__INTEL_COMPILER" macros.
1516 Warning: can prevent correct Intel header compilation
1517
1518-no-gcc-include-dir
1519 Do not add the gcc version specific system include directory
1520
1521-pragma-optimization-level=[Intel|GCC]
1522 process #pragma optimize using Intel (DEFAULT) or GCC syntax
1523
1524
1525Component Control
1526-----------------
1527
1528
1529
1530-Qoption,<tool>,<opts>
1531 pass options <opts> to tool specified by <tool>
1532
1533-Qlocation,<tool>,<dir>
1534 set <dir> as the location of tool specified by <tool>
1535
1536-Qinstall <dir>
1537 set <dir> as root of compiler installation
1538
1539
1540Language
1541--------
1542
1543
1544
1545-std=<std>
1546 enable language support for <std>, as described below
1547 c99 conforms to ISO/IEC 9899:1999 standard for C programs
1548 c11 conforms to ISO/IEC 9899:2011 standard for C programs
1549 c++11 enables C++11 support for C++ programs
1550 c++14 enables experimental C++14 support for C++ programs
1551 c++17 enables experimental c++17 support for C++ programs
1552
1553 c89 conforms to ISO/IEC 9899:1990 standard for C programs
1554 gnu89 conforms to ISO C90 plus GNU extensions
1555 gnu99 conforms to ISO C99 plus GNU extensions
1556 gnu++98 conforms to 1998 ISO C++ standard plus GNU extensions
1557 gnu++11 conforms to 2011 ISO C++ standard plus GNU extensions
1558
1559-x <type>
1560 all source files found subsequent to -x <type> will be recognized
1561 as one of the following types:
1562 c - C source file
1563 c++ - C++ source file
1564 c-header - C header file
1565 cpp-output - C pre-processed file
1566 c++-cpp-output - C++ pre-processed file
1567 assembler - assembly file
1568 assembler-with-cpp - assembly file that needs to be preprocessed
1569 none - revert to original file extension
1570
1571-ansi equivalent to GNU -ansi
1572
1573-strict-ansi
1574 strict ANSI conformance dialect
1575
1576-Zp[n] specify alignment constraint for structures where
1577 n=1,2,4,8,16. 16 is the default
1578
1579-fsyntax-only
1580 perform syntax and semantic checking only (no object file produced)
1581
1582-trigraphs
1583 support ISO C trigraphs (enabled in -ansi mode)
1584
1585-fpermissive
1586 allows extensions for some non-conformant code
1587
1588-funsigned-char
1589 change default char type to unsigned
1590
1591-fshort-enums
1592 allocate as many bytes as needed for enumerated types
1593
1594-f[no-]unsigned-bitfields
1595 change default bitfield type to unsigned
1596
1597-fno-rtti
1598 disable RTTI support
1599
1600-fno-implicit-templates
1601 never emit code for non-inline templates which are instantiated
1602 implicitly; only emit code for explicit instantiations
1603
1604-fno-implicit-inline-templates
1605 do not emit code for implicit instantiations of inline templates
1606
1607-ftemplate-depth=n
1608 control the depth in which recursive templates are expanded
1609
1610-[no]align
1611 analyze and reorder memory layout for variables and arrays
1612
1613-[no-]restrict
1614 enable/disable the 'restrict' keyword for disambiguating pointers
1615
1616-[no-]early-template-check
1617 enable/disable (DEFAULT) semantic checking of function template
1618 prototypes (before instantiation).
1619
1620-help-pragma
1621 output supported pragmas and their usage syntax
1622
1623-ffriend-injection
1624 inject friend functions into the enclosing namespace. Use
1625 -fno-friend-injection to disable
1626
1627-check=<keyword>[,<keyword>,...]
1628 check run-time conditions.
1629 keywords: [no]conversions, [no]stack, [no]uninit
1630
1631-qopt-assume-safe-padding
1632 assume that variables and dynamically allocated memory are padded
1633 (Intel(R) MIC Architecture specific)
1634
1635
1636Compiler Diagnostics
1637--------------------
1638
1639
1640
1641-w disable all warnings
1642
1643-w<n> control diagnostics
1644 n = 0 enable errors only (same as -w)
1645 n = 1 enable warnings and errors (DEFAULT)
1646 n = 2 enable verbose warnings, warnings and errors
1647 n = 3 enable remarks, verbose warnings, warnings and errors
1648
1649-Wbrief print brief one-line diagnostics
1650
1651-Werror force warnings to be reported as errors
1652
1653-Werror-all
1654 force warnings and currently enabled remarks to be reported as errors
1655
1656-Wall enable all warnings
1657
1658-Wremarks
1659 enable all remarks and comments
1660
1661-Wcheck enable more strict diagnostics
1662
1663-Weffc++ enable effective C++ diagnostic warnings
1664
1665-wo<L1>[,<L2>,...]
1666 issue diagnostics L1 through LN only once
1667
1668-W[no-]fatal-errors
1669 ends compilation after the first error encountered
1670
1671-W[no-]format
1672 enable argument checking for calls to printf, scanf, etc
1673
1674-W[no-]format-security
1675 warn for uses of format strings and specifiers in printf,
1676 scanf, etc that may introduce security problems
1677
1678-W[no-]missing-declarations
1679 warn for global functions and variables without prior declaration
1680
1681-W[no-]missing-prototypes
1682 warn for missing prototypes
1683
1684-W[no-]strict-aliasing
1685 warn for code that might violate the optimizer's strict aliasing
1686 rules. Warnings are issued only when using -fstrict-aliasing or
1687 -ansi-alias.
1688
1689-W[no-]strict-prototypes
1690 warn for functions declared or defined without specified argument
1691 types
1692
1693-W[no-]pointer-arith
1694 warn for questionable pointer arithmetic
1695
1696-W[no-]uninitialized
1697 warn if a variable is used before being initialized
1698
1699-Winline enable inline diagnostics
1700
1701-W[no-]deprecated
1702 print warnings related to deprecated features
1703
1704-W[no-]abi
1705 warn if generated code is not C++ ABI compliant
1706
1707-Wcontext-limit=<n>
1708 set maximum number of template instantiation contexts shown in
1709 diagnostic
1710
1711-Wcast-qual
1712 warn if cast is used to override pointer type qualifier
1713
1714-W[no-]unused-function
1715 warn if declared function is not used
1716
1717-W[no-]unused-parameter
1718 warn if declared function parameter is not used
1719
1720-W[no-]unknown-pragmas
1721 warn if an unknown #pragma directive is used (DEFAULT)
1722
1723-W[no-]main
1724 warn if return type of main is not expected
1725
1726-W[no-]comment[s]
1727 warn when comment
1728
1729-W[no-]conversion
1730 warn for implicit conversions that may alter a value
1731
1732-W[no-]return-type
1733 Issue warnings when a function is declared without a return type or
1734 when the definition of a function returning void contains a return
1735 statement with an expression
1736
1737-W[no-]extra-tokens
1738 warn about extra tokens after preprocessor directives
1739
1740-W[no-]invalid-pch
1741 warn about problems with existing precompiled headers
1742
1743-W[no-]shadow
1744 warn when a variable declaration hides a previous declaration
1745
1746-Woverloaded-virtual
1747 warn when a function declaration hides virtual functions from a base
1748 class
1749
1750-W[no-]trigraphs
1751 warn about the recognition and conversion of trigraphs
1752
1753-W[no-]multichar
1754 warn if a multicharacter constant ('ABC') is used
1755
1756-W[no-]overflow
1757 warn for operations that could result in integer overflow
1758
1759-Wwrite-strings
1760 Issues a diagnostic message if const char * is converted
1761 to (non-const) char *.
1762
1763-W[no-]sign-compare
1764 warn for comparisons between signed and unsigned values that
1765 could produce unintended results after sign conversion
1766
1767-W[no-]ic-pointer
1768 warn for conversions between pointers to distinct scalar types
1769 with the same representation
1770
1771-Wp64 print diagnostics for 64-bit porting
1772
1773-W[no-]shorten-64-to-32
1774 warn for values implicitly converted from a 64-bit to a 32-bit type.
1775 Similar to -Wp64
1776
1777-[no]traceback
1778 specify whether the compiler generates data to allow for source file
1779 traceback information at runtime (only to be used when linking with
1780 Fortran programs)
1781
1782-diag-enable=<v1>[,<v2>,...]
1783 enable the specified diagnostics or diagnostic groups
1784
1785-diag-disable=<v1>[,<v2>,...]
1786 disable the specified diagnostics or diagnostic groups
1787
1788 where <vN> may be individual diagnostic numbers or group names.
1789 where group names include:
1790
1791 thread - diagnostics to aid in thread-enabling source
1792 power - controls whether diagnostics are enabled for
1793 possibly inefficient code that may affect power
1794 consumption when running on Intel(R) processors
1795
1796 port-win - diagnostics for GNU extensions that may
1797 cause errors when porting to Windows
1798
1799 openmp - diagnostics issued by the OpenMP* parallelizer
1800
1801 warn - diagnostics that have "warning" severity level
1802 error - diagnostics that have "error" severity level
1803 remark - diagnostics that are remarks or comments
1804
1805 vec - diagnostics issued by the vectorizer
1806 par - diagnostics issued by the auto-parallelizer
1807 cpu-dispatch
1808 - specifies the CPU dispatch remarks
1809
1810-diag-error=<v1>[,<v2>,...]
1811 output the specified diagnostics or diagnostic groups as errors
1812
1813-diag-warning=<v1>[,<v2>,...]
1814 output the specified diagnostics or diagnostic groups as warnings
1815
1816-diag-remark=<v1>[,<v2>,...]
1817 output the the specified diagnostics or diagnostic groups as remarks
1818
1819-diag-dump
1820 display the currently enabled diagnostic messages to stdout or to a
1821 specified diagnostic output file.
1822
1823-diag-file[=<file>]
1824 <file> where diagnostics are emitted to. Not specifying this causes
1825 messages to be output to stderr
1826
1827-diag-file-append[=<file>]
1828 <file> where diagnostics are emitted to. When <file> already exists,
1829 output is appended to the file
1830
1831-[no-]diag-id-numbers
1832 enable(DEFAULT)/disable the diagnostic specifiers to be output in
1833 numeric form
1834
1835-diag-error-limit=<num>
1836 specify the maximum number of errors emitted
1837
1838-diag-once=<v1>[,<v2>,...]
1839 issue diagnostics v1 through vN only once
1840
1841-W[no-]pch-messages
1842 enable(DEFAULT)/disable PCH information messages
1843
1844
1845Miscellaneous
1846-------------
1847
1848
1849
1850-V display compiler version information
1851
1852-dumpversion
1853 display the compiler version number only
1854
1855-dumpmachine
1856 display the target machine only
1857
1858--version
1859 display GCC style version information
1860
1861-sox[=<keyword>[,keyword]]
1862 enable saving of compiler options, version and additional information
1863 in the executable. Use -no-sox to disable(DEFAULT)
1864 profile - include profiling data
1865 inline - include inlining information
1866
1867-save-temps
1868 store the intermediate files in current directory and name them
1869 based on the source file. Only saves files that are generated by
1870 default
1871
1872-dryrun show driver tool commands but do not execute tools
1873
1874-v show driver tool commands and execute tools
1875
1876-watch=<keyword>
1877 tells the driver to output processing information
1878 keywords: all, none (same as -nowatch), [no]source,
1879 [no]cmd (same as -v)
1880
1881 [no]mic-cmd
1882
1883-nowatch suppress processing information output (DEFAULT)
1884
1885-[no-]multibyte-chars
1886 provide support for multi-byte characters
1887
1888-multiple-processes[=<n>]
1889 create multiple processes that can be used to compile large numbers
1890 of source files at the same time
1891
1892-standalone
1893 create standalone compilation environment, helpful for bootstrap
1894 environments where gcc is not available during the build
1895
1896
1897Offload
1898-------
1899
1900
1901
1902-qoffload=<arg>
1903 define whether offload is enabled, and if enabled, whether CPU
1904 fallback is permitted
1905 keywords: none, optional, mandatory
1906
1907-qoffload-attribute-target=<name>
1908 flags every global routine and global data object in the source
1909 file with the offload attribute target(<name>)
1910 name - mic, gfx (gfx for C/C++ compilation only)
1911
1912-qoffload-option,<target>,<tool>,"option list"
1913 appends additional options for offload compilations given the
1914 target and tool. The option list is a space separated quoted list
1915 of options
1916 target - mic, gfx (gfx for C/C++ compilation only)
1917 tool - compiler, ld, as, jit (gfx only)
1918
1919-qno-offload
1920 disable any offload usage
1921
1922-qoffload-arch=<arch>[:<visa>]
1923 specify the target architecture to use when offloading code
1924 arch - Specifies the target architecture. On Intel(R) 64
1925 architecture targeting Intel(R) MIC Architecture, arch can
1926 be mic or mic-avx512. On IA-32 and Intel(R) 64 architectures
1927 targeting Intel(R) Graphics Technology, arch can be
1928 ivybridge, haswell, broadwell, or cherryview.
1929 visa - Specifies the virtual ISA (vISA) version to be used. This
1930 optional argument is only allowed on IA-32 and Intel(R) 64
1931 architectures targeting Intel(R) Graphics Technology. You
1932 can specify either visa3.0 or visa3.1.
1933
1934-q[no-]offload-svm
1935 Determines whether the compiler uses Shared Virtual Memory (SVM)
1936 mode. This option only applies to Intel(R) Graphics Technology.
1937
1938
1939Data
1940----
1941
1942
1943
1944-Zp[n] specify alignment constraint for structures (n=1,2,4,8,16
1945 -Zp16 DEFAULT)
1946
1947-fminshared
1948 Compilation is for the main executable. Absolute addressing can be
1949 used and non-position independent code generated for symbols that
1950 are at least protected
1951
1952-fcommon Enables the compiler to treat common variables as if they were
1953 defined. That in turn allows the use of gprel addressing of common
1954 data variables. -fno-common disables
1955
1956-freg-struct-return
1957 return struct and union values in registers when possible
1958
1959-fstack-security-check
1960 enable overflow security checks.
1961 -fno-stack-security-check disables (DEFAULT)
1962
1963-fstack-protector
1964 enable stack overflow security checks.
1965 -fno-stack-protector disables (DEFAULT)
1966
1967-fstack-protector-strong
1968 enable stack overflow security checks for routines with any buffer.
1969 -fno-stack-protector-strong disables (DEFAULT)
1970
1971-fstack-protector-all
1972 enable stack overflow security checks including functions.
1973 -fno-stack-protector-all disables (DEFAULT)
1974
1975-fpic, -fPIC
1976 generate position independent code (-fno-pic/-fno-PIC is DEFAULT)
1977
1978-fpie, -fPIE
1979 generate position independent code that will be linked into an
1980 executable (-fno-pie/-fno-PIE is DEFAULT)
1981
1982-auto-ilp32
1983 specify that the application cannot exceed a 32-bit address space
1984 (-ipo[n] required)
1985
1986-auto-p32 instructs the compiler to analyze the program to determine if there
1987 are 64-bit pointers that can be safely shrunk to 32-bit pointers.
1988 (-ipo required)
1989
1990-[no-]global-hoist
1991 enable(DEFAULT)/disable external globals are load safe
1992
1993-f[no-]keep-static-consts
1994 enable/disable(DEFAULT) emission of static const variables even
1995 when not referenced
1996
1997-fpack-struct
1998 pack structure members together
1999
2000-f[no-]math-errno
2001 set ERRNO after calling standard math library functions
2002
2003-no-bss-init
2004 disable placement of zero-initialized variables in BSS (use DATA)
2005
2006-f[no-]zero-initialized-in-bss
2007 put explicitly zero initialized variables into the DATA section
2008 instead of the BSS section
2009
2010-mcmodel=<size>
2011 use a specific memory model to generate code and store data
2012 small - Restricts code and data to the first 2GB of address
2013 space (DEFAULT)
2014 medium - Restricts code to the first 2GB; it places no memory
2015 restriction on data
2016 large - Places no memory restriction on code or data
2017
2018-falign-functions=<n>
2019 align the start of functions on a 2 (DEFAULT) or <n> byte boundary
2020 where <n> is a power of 2
2021
2022-falign-functions
2023 align the start of functions to an optimal machine-dependent value.
2024 -fno-align-functions (DEFAULT) aligns on a 2-byte boundary
2025
2026-fvisibility=[extern|default|protected|hidden|internal]
2027 Global symbols (data and functions) will get the visibility
2028 attribute given by default. Symbol visibility attributes explicitly
2029 set in the source code or using the symbol visibility attribute
2030 file options will override the -fvisibility setting
2031
2032-fvisibility-extern=<file>
2033 Space separated symbols listed in the <file> argument will get
2034 visibility set to extern
2035
2036-fvisibility-default=<file>
2037 Space separated symbols listed in the <file> argument will get
2038 visibility set to default
2039
2040-fvisibility-protected=<file>
2041 Space separated symbols listed in the <file> argument will get
2042 visibility set to protected
2043
2044-fvisibility-hidden=<file>
2045 Space separated symbols listed in the <file> argument will get
2046 visibility set to hidden
2047
2048-fvisibility-internal=<file>
2049 Space separated symbols listed in the <file> argument will get
2050 visibility set to internal
2051
2052-fvisibility-inlines-hidden
2053 mark inline member functions as hidden
2054
2055-mlong-double-64
2056 enable 64-bit 'long double'
2057 80-bit floating-point type is available as __float80.
2058
2059-mlong-double-80
2060 enable 80-bit 'long double'
2061
2062
2063Compatibility
2064-------------
2065
2066
2067
2068-gcc-name=<name>
2069 name and location of gcc if not where expected
2070
2071-gxx-name=<name>
2072 name and location of g++ if not where expected
2073
2074-fabi-version=<val>
2075 directs the compiler to select a specific ABI implementation
2076 0 - most recent ABI implementation
2077 1 - g++ 3.2 compatible ABI implementation
2078 2 - most conformant ABI implementation
2079
2080-fms-dialect[=<arg>]
2081 enable compatibility with a specific Microsoft* Visual Studio
2082 version
2083 10 - Microsoft* Visual Studio 2010 compatibility
2084 11 - Microsoft* Visual Studio 2012 compatibility
2085 12 - Microsoft* Visual Studio 2013 compatibility
2086 14 - Microsoft* Visual Studio 2015 compatibility
2087
2088-gnu-prefix=prefix
2089 specify a prefix that will be added to the names of GNU utilities
2090 called from the compiler
2091
2092
2093Linking/Linker
2094--------------
2095
2096
2097
2098-L<dir> instruct linker to search <dir> for libraries
2099
2100-l<string>
2101 instruct the linker to link in the -l<string> library
2102
2103-shared-intel
2104 link Intel provided libraries dynamically
2105
2106-static-intel
2107 link Intel provided libraries statically
2108
2109-shared-libgcc
2110 link libgcc dynamically
2111
2112-static-libgcc
2113 link libgcc statically
2114
2115-static-libstdc++
2116 link libstdc++ statically
2117
2118-dynamic-linker<file>
2119 select dynamic linker other than the default
2120
2121-no-cxxlib
2122 do not link in C++ runtime libraries
2123
2124-cxxlib[=dir]
2125 link using C++ run-time libraries provided with gcc dir is an
2126 optional top-level location for the gcc binaries and libraries
2127
2128-nodefaultlibs
2129 do not use standard libraries when linking
2130
2131-nostartfiles
2132 do not use standard startup files when linking
2133
2134-nostdlib
2135 do not use standard libraries and startup files when linking
2136
2137-static prevents linking with shared libraries
2138
2139-shared produce a shared object
2140
2141-Bstatic specify following libraries are linked statically
2142
2143-Bdynamic
2144 specify following libraries are linked dynamically
2145
2146-pthread use POSIX* thread library for multithreading support
2147
2148-cxxlib-<mode>
2149 tell the compiler which C++ run-time libraries to use
2150 nostd - do not link in standard C++ library
2151
2152-u <symbol>
2153 pretend the <symbol> is undefined
2154
2155-T <file>
2156 direct linker to read link commands from <file>
2157
2158-Xassembler <val>
2159 pass <val> directly to the assembler for processing
2160
2161-Xlinker <val>
2162 pass <val> directly to the linker for processing
2163
2164-Wa,<o1>[,<o2>,...]
2165 pass options o1, o2, etc. to the assembler
2166
2167-Wl,<o1>[,<o2>,...]
2168 pass options o1, o2, etc. to the linker for processing
2169
2170-Wp,<o1>[,<o2>,...]
2171 pass options o1, o2, etc. to the preprocessor
2172
2173-pie,-no_pie
2174 generate position independent code that will be linked into an
2175 executable (-pie is DEFAULT for OS X* 10.7 and later)
2176 -no-pie/-no_pie disables position independent code
2177
2178
2179Linker Specific Options
2180-----------------------
2181
2182These options are specific to the linker. Details can be found in the linker
2183documentation and man page
2184
2185-L<dir>
2186-T<arg>
2187-h<arg>
2188-u<arg>
2189-z<arg>
2190-i
2191-r
2192-s
2193-N
2194-Bsymbolic
2195
2196-Bdynamic
2197-Bstatic
2198
2199
2200Deprecated Options
2201------------------
2202
2203
2204
2205-Ob use -inline-level=<n>
2206-use-asm No replacement
2207-gcc-version use -gcc-name=<name>
2208-qopt-report [n] use -qopt-report[=n]
2209-offload-attribute-target=<target> use -qoffload-attribute-target=<target>
2210-offload-option,<target>,<tool>,<opts> use
2211 -qoffload-option,<target>,<tool>,<opts>
2212-[no-]offload[=<arg>] use -q[no-]offload[=<arg>]
2213-opt-args-in-regs=<arg> use -qopt-args-in-regs=<arg>
2214-[no-]opt-assume-safe-padding use -q[no-]opt-assume-safe-padding
2215-opt-block-factor=<arg> use -qopt-block-factor=<arg>
2216-[no-]opt-calloc use -q[no-]opt-calloc
2217-[no-]opt-class-analysis use -q[no-]opt-class-analysis
2218-[no-]opt-dynamic-align use -q[no-]opt-dynamic-align
2219-[no-]opt-gather-scatter-unroll use -q[no-]opt-gather-scatter-unroll
2220-[no-]opt-jump-tables=<arg> use -q[no-]opt-jump-tables=<arg>
2221-opt-malloc-options=<arg> use -qopt-malloc-options=<arg>
2222-[no-]opt-matmul use -q[no-]opt-matmul
2223-[no-]opt-mem-layout-trans=<arg> use -q[no-]opt-mem-layout-trans=<arg>
2224-[no-]opt-multi-version-aggressive use -q[no-]opt-multi-version-aggressive
2225-[no-]opt-prefetch[=<val>] use -q[no-]opt-prefetch[=<val>]
2226-opt-prefetch-distance=<arg> use -qopt-prefetch-distance=<arg>
2227-opt-ra-region-strategy[=<arg>] use -qopt-ra-region-strategy[=<arg>]
2228-[no-]opt-report-embed use -q[no-]opt-report-embed
2229-opt-report-file=<arg> use -qopt-report-file=<arg>
2230-opt-report-filter=<arg> use -qopt-report-filter=<arg>
2231-opt-report-format=<arg> use -qopt-report-format=<arg>
2232-opt-report-phase=<arg> use -qopt-report-phase=<arg>
2233-opt-report-routine=<arg> use -qopt-report-routine=<arg>
2234-opt-report-help use -qopt-report-help
2235-opt-report[=<arg>] use -qopt-report[=<arg>]
2236-opt-report-per-object use -qopt-report-per-object
2237-opt-streaming-cache-evict=<arg> use -qopt-streaming-cache-evict=<arg>
2238-opt-streaming-stores=<arg> use -qopt-streaming-stores=<arg>
2239-[no-]opt-subscript-in-range use -q[no-]opt-subscript-in-range
2240-opt-threads-per-core=<arg> use -qopt-threads-per-core=<arg>
2241
2242-vec-report[=n] use -qopt-report[=n] -qopt-report-phase=vec
2243-par-report[=n] use -qopt-report[=n] -qopt-report-phase=par
2244
2245-[no-]openmp use -q[no-]openmp
2246-openmp-lib=<arg> use -qopenmp-lib=<arg>
2247-openmp-link=<arg> use -qopenmp-link=<arg>
2248-[no-]openmp-offload use -q[no-]openmp-offload
2249-[no-]openmp-simd use -q[no-]openmp-simd
2250-openmp-stubs use -qopenmp-stubs
2251-openmp-threadprivate=<arg> use -qopenmp-threadprivate=<arg>
2252-openmp-report[=<level>] use -qopenmp-report[=<level>]
2253-openmp-task=<arg> use -qopenmp-task=<arg>
2254-openmp-report[=n] use -qopt-report[=n] -qopt-report-phase=openmp
2255
2256-xT use -xSSSE3
2257-axT use -axSSSE3
2258-xS use -xSSE4.1
2259-axS use -axSSE4.1
2260-xSSE3_ATOM use -xATOM_SSSE3
2261-xSSSE3_ATOM use -xATOM_SSSE3
2262
2263-[no-]check-uninit use -check=[no]uninit
2264-fwritable-strings no replacement
2265-Kc++ use -x c++
2266-wn use -diag-error-limit
2267-wd use -diag-disable
2268-we use -diag-error
2269-ww use -diag-warning
2270-wr use -diag-remark
2271-wo use -diag-once
2272-std=c9x use -std=c99
2273
2274
2275
2276
2277-help [category] print full or category help message
2278
2279
2280
2281Valid categories include
2282 advanced - Advanced Optimizations
2283 codegen - Code Generation
2284 compatibility - Compatibility
2285 component - Component Control
2286 data - Data
2287 deprecated - Deprecated Options
2288 diagnostics - Compiler Diagnostics
2289 float - Floating Point
2290 help - Help
2291 inline - Inlining
2292 ipo - Interprocedural Optimization (IPO)
2293 language - Language
2294 link - Linking/Linker
2295 misc - Miscellaneous
2296 opt - Optimization
2297 output - Output
2298 pgo - Profile Guided Optimization (PGO)
2299 preproc - Preprocessor
2300 reports - Optimization Reports
2301
2302 openmp - OpenMP and Parallel Processing
2303
2304
2305Copyright (C) 1985-2016, Intel Corporation. All rights reserved.
2306* Other names and brands may be claimed as the property of others.