Fujitsu Siemens Computers SPEC CPU2006 Flag Description

Maximize speed across the entire program.

Turns on:

• -O3
• -prec-div
• -xP
• -ipo
• -static

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 -ax or -x, 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.

-xprocessor    This option directs the compiler to generate specialized and optimized code for the Intel processor that executes your program. It lets you target your program to run on a specific Intel processor.

processor    Is the processor for which you want to target your program.
Here: P    Code is optimized for Intel Core Duo processors, Intel Core Solo processors, Intel Pentium 4 processors with Steaming SIMD Extensions 3, and compatible Intel processors with Streaming SIMD Extensions 3. The resulting code may contain unconditional use of features that are not supported on other processors.
This option also enables new optimizations in addition to Intel processor-specific optimizations including advanced data layout and code restructuring optimizations to improve memory accesses for Intel processors.

Programs compiled with -xP will display a fatal run-time error if they are executed on unsupported processors.

On Intel EM64T systems, W, and P, are the only valid processor values.

-ipo[n]

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

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

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

n    Is an optional integer that specifies the number of object files the compiler should create. The integer must be greater than or equal to 0.
If you do not specify n, the default is 0.

If n is 0, the compiler decides whether to create one or more object files based on an estimate of the size of the application. It generates one object file for small applications, and two or more object files for large applications.

If n is greater than 0, the compiler generates n object files, unless n exceeds the number of source files (m), in which case the compiler generates only m object files.

-static prevents linking with shared libraries.

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

This option instruments a program for profiling as first step in Profile Guided Optimization.

Profile Guided Optimization (PGO) consists of 3 phases:
Phase 1: Compile and generate instrumented code in preparation to gather profiling information (compiler flag -prof_gen).
Phase 2: Execute the instrumented code and gather profiling information.
Phase 3: Recompile the code and use the profiling information for improved optimization (compiler flag -prof_use).

The option -prof_gen instruments a program for profiling to get the execution count of each basic block. It also creates a new static profile information file (.spi). This flag 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.

The instrumented code

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

This option enables the use of profiling information during optimization as final step in Profile Guided Optimization.

Profile Guided Optimization (PGO) consists of 3 phases:
Phase 1: Compile and generate instrumented code in preparation to gather profiling information (compiler flag -prof_gen).
Phase 2: Execute the instrumented code and gather profiling information.
Phase 3: Recompile the code and use the profiling information for improved optimization (compiler flag -prof_use).

The option -prof_use instructs the compiler to use the profiling information from phase 2 of PGO in order to produce a profile-optimized executable (phase 3 of PGO).

It also enables function splitting (option -Qfnsplit) and function grouping during optimization.

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

The recompilation with -prof_use

• 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 -prof-use is also specified. Otherwise, this option has no effect.

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

To disable function splitting when you use -prof-use, specify -fnsplit-.

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

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 W, P while also generating generic IA-32 code.

• W = Intel Pentium 4 and compatible 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.

-DSPEC_CPU_LP64 compiles using LP64 programming model.

Compile for an I386 system running Linux.

So as to use the built-in optimized alloc.

-DSPEC_CPU_LINUX compiles for a system running Linux.

For mixed-language benchmarks, tell the compiler that the main program is not written in Fortran.

This macro indicates that Fortran functions called from C should have their names lower-cased.

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

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

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