Fujitsu Siemens Computers SPEC CPU2006 Flag Description

Specifies the stack reserve amount for the program.

-F<n>
<n> is the stack reserve amount. It can be specified as a decimal integer or by using a C-style convention for constants (for example, -F0x1000).
Default: The stack size default is chosen by the operating system.

Maximize speed across the entire program.

Turns on:

• -O3
• -Qprec-div-
• -QxP
• -Qipo

Optimizes for speed. Enables high-level optimization. This level does not guarantee higher performance. Using this option may increase the compilation time. Impact on performance is application dependent, some applications may not see a performance improvement.

The optimizations include:

• All optimizations done with -O2
• loop unrolling, including instruction scheduling
• code replication to eliminate branches
• padding the size of certain power-of-two arrays to allow more efficient cache use.
• When used with -Qax or -Qx, it causes the compiler to perform more aggressive data dependency analysis than for -O2.

Enables[disables] improved precision of floating-point divides. Disabling may slightly improve speed. Default Enabled.

Generate specialized code to run exclusively on processors supporting the extensions indicated by [codes] as described above.
P stands for Pentium.

for C and C++

Enables multi-file ip optimizations which allows inline function expansion for calls to functions defined in separate files. The compiler decides whether to create one or more object files based on an estimate of the size of the application. It generates one object file for small applications and two for large ones.

for Fortran

multi-file ip optimizations that includes:

• inline function expansion
• interprocedural constant propagation
• monitoring module-level static variables
• dead code elimination
• propagation of function characteristics
• passing arguments in registers
• loop-invariant code motion

Optimizes for speed.
The -O2 option includes the following options:

• -Og
• -Oi-
• -Os
• -Oy
• -Ob1
• -Gs

This options defaults to ON.

This option also enables.

• inlining of intrinsics
• Intra-file interprocedural optimizations including:
• inlining
• constant propagation
• forward substitution
• routine attribute propagation
• variable address-taken analysis
• dead static function elimination
• removal of unreferenced variables.
• The following performance optimizations:
• copy propogation.
• dead-code elimination
• global register allocation
• global instruction scheduling and control speculation
• loop unrolliing
• optimized code selection
• partial redundancy elimination
• strength reduction/induction variable simplification
• variable renaming
• exception handling optimizations
• tail recursions
• peephole optimizations
• structure assignment lowering and optimization
• dead store elimination

Enables single-file interprocedural optimizations within a file.

Instruments a program for profiling.

This option instruments a program for profiling to get the execution count of each basic block. It also creates a new static profile information file (.spi).

It is used in phase 1 of the Profile Guided Optimizer (PGO) to instruct the compiler to produce code in your object files in preparation for instrumented execution.

• Gathers information regarding execution paths.
• Gathers information regarding data values.
• Does not use hardware performance counters.

Enables the use of profiling information during optimization.

This option enables the use of profiling information (including function splitting and function grouping) during optimization. It enables option -Qfnsplit.

This option instructs the compiler to produce a profile-optimized executable and it merges available profiling output files into a pgopti.dpi file.

Note that there is no way to turn off'function grouping if you enable it using this option.

• Uses information regarding execution paths.
• Uses information regarding data values.
• Does not use hardware performance counters.
• Uses techniques (like function grouping) which are not available without PGO.

Enables function splitting.

This option enables function splitting if -Qprof-use is also specified. Otherwise, this option has no effect.

It is enabled automatically if you specify -Qprof-use. If you do not specify one of those options, the default is -Qfnsplit-, which disables function splitting but leaves function grouping enabled.

To disable function splitting when you use -Qprof-use, specify -Qfnsplit-.

Enables global optimizations.

Enables/disables inline expansion of intrinsic functions.

Default enabled

This option enables most speed optimizations, but disables some that increase code size for a small speed benefit.

Default enabled

Enables [disables] the use of the EBP register in optimizations. When you disable with -Oy-, the EBP register is used as frame pointer. -Oy has the effect of reducing the number of general-purpose registers by 1, and can produce slightly less efficient code.

Default enabled

n = 0
Disables inlining of user-defined functions. However, statement functions are always inlined

n = 1
Enables inlining of functions declared with the __inline keyword. Also enables inlining according to the C++ language

n = 2
Enables inlining of any function. However, the compiler decides which functions are inlined. This option enables interprocedural optimizations and has the same effect as specifying option Qip.

Default enabled with n = 2

Disables stack-checking for routines with n or more bytes of local variables and compiler temporaries.

Default enabled with n = 4096.

Assume [not assume] no aliasing

Default disabled

Enables all speed optimizations.

Overrides -Os

Assume[not assume] no cross function aliasing.

Enables string-pooling optimization.

Packages functions to enable linker optimization.

Default enabled

Generates specialized code for processor specific codes K, W, N, P while also generating generic IA-32 code.

• K = Intel Pentium III and compatible Intel processors
• W = Intel Pentium 4 and compatible Intel processors
• N = Intel Pentium 4 and compatible Intel processors. These options also enable advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.
• P = Intel Pentium 4 processor with Streaming SIMD 3 (SSE3) support. These option also enable advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.

Enables[disables] fast conversions of floating-point to integer conversions. This option does not guarantee that any particular rounding mode will be used.

for C and C++

Qansi_alias directs the compiler to assume the following:
• Arrays are not accessed out of bounds.
• Pointers are not cast to non-pointer types, and vice-versa.
• References to objects of two different scalar types cannot alias. For example, an object of type int cannot alias with an object of type float, or an object of type float cannot alias with an object of type double.

If your program satisfies the above conditions, setting the -Qansi_alias flag will help the compiler better optimize the program. However, if your program does not satisfy one of the above conditions, the -Qansi_alias flag may lead the compiler to generate incorrect code.

for Fortran
Enables (default) or disables the compiler to assume that the program adheres to the ANSI Fortran type aliasablility rules. For example, an object of type real cannot be accessed as an integer. You should see the ANSI Standard for the complete set of rules.

round fp results at assignments & casts (some speed impact)

Enable prefetch insertion.

Default enabled

Specifies the maximum number of times to unroll a loop. n = 0 disables loop unrolling.

Default: the compiler uses default heuristics when unrolling loops.

-Qoption: passes an option specified by optlist to a tool, where optlist is a comma-separated list of options.
for C and C++

NOTE: If tool is incorrectly specified, the compiler gives an warning and the option is ignored. For example, if -Qoption,f,... is used with the Intel C++ compiler, the option is ignored with an warning.

-Qoption can be used with the -Qipo flag to refine IPO.
The valid options that can be used for this purpose are:

• -ip_args_in_regs = 0
  Disables the passing of arguments in registers.
• -ip_ninl_max_stats = n
  Sets the valid max number of intermediate language statements for a function that is expanded in line. The number n is a positive integer. The number of intermediate language statements usually exceeds the actual number of source language statements. The default value for n is 230. The compiler uses a larger limit for user inline functions
• -ip_ninl_min_stats = n
  Sets the valid min number of intermediate language statements for a function that is expanded in line. The number n is a positive integer. The default values for ip_ninl_min_stats are:
  IA-32 compiler: ip_ninl_min_stats = 7
• -ip_ninl_max_total_stats = n
  Sets the maximum increase in size of a function, measured in intermediate language statements, due to inlining. n is a positive integer whose default value is 2000.

Specifies the strictest alignment constraint for structure and union types as 1, 2. 4. 8 or 16 bytes

Default is 16.

Problem: 16 is also possible. How to write regexp?

Enables the compiler to use SSE instructions.

Enables the compiler to use SSE2 instructions.

Enables floating-point significand precision control. The value is used to round the significand to the correct number of bits. The value must be either 32, 64 or 80.

Default enabled

Same as the -O2 option: enables -Gs, and -Ob1, -Og, -Oy, and -Ot.

Determines whether local variables are put on the run-time stack.

Enables[disables] scalar replacement performed during loop transformations.
(requires /O3).

Force Linking even if multiple entry names are found.

MicroQuill SmartHeap Library.
Available from http://www.microquill.com/

-TP tells the compiler to process all source or unrecognized file types as C++ source files.
Default: The compiler assumes that files with the extension .c or .C are C source files. To handle them as C++ source files, the compiler flag -TP is needed.

-Qlowercase causes the compiler to ignore case differences in identifiers and to convert external names to lowercase.
It is needed to specify the naming convention for mixing C and Fortran codes.

-assume:[no]underscore
Determines whether the compiler appends an underscore character to external user-defined names.
-assume:underscore is needed to specify the naming convention for mixing C and Fortran codes.

Invoke Intel C/C++ compiler.
Also used to invoke linker for C/C++ programs.

Invoke Intel Fortran compiler.
Also used to invoke linker for Fortran programs and C/Fortran mixtures.

This option enables/disables C99 support for C programs.

This option enables standard C++ features without disabling Microsoft features within the bounds of what is provided in the Microsoft headers and libraries.

This option has the same effect as specifying -GX -GR.

-GX Enables C++ exception handling.
-GR Enables C++ Run Time Type Information (RTTI).