x86 Open64 Compiler Suite SPEC CPU2006 Flag Description

Set the optimization level to -O2.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".

No optimizations are performed.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".

Perform minimal local optimizations on sections of straight-line code (basic blocks) only. Examples of such optimizations are instruction scheduling and some peephole optimizations. These optimizations do not usually have any noticeable impact on compilation time.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".

Perform extensive global optimizations. Examples of such optimizations are control flow optimizations, partial redundancy elimination, and strength reduction. These optimizations can very often reduce the execution time of the compiled program significantly, but they may do so at the expense of increased compilation time. This is the default level of optimization.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".

Perform all the optimizations at the -O2 level as well as many more aggressive optimizations. Examples of such aggressive optimizations are loop nest optimizations and generation of prefetch instructions. Although these more aggressive optimizations can significantly speed up the run time execution of the compiled program, in rare cases they may not be profitable and may instead lead to a slow down. Also, some of these more aggressive optimizations may affect the accuracy of some floating point computations.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".

Optimize for size. "-Os" enables all "-O2" optimizations that do not typically increase code size. It also performs further optimizations designed to reduce code size.

If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2").

Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may be affected due to the transformation of the computational code. Note the interprocedural analysis option, -ipa, specifies limitations on how libraries and object files (.o files) are built.

Instructs the compiler to automatically transform sequential code into parallel code. The compiler will only transform blocks of code that will demonstrate a speed-up to the runtime (i.e. execute faster) on a multiprocessor target.

The default number of threads used at run-time is either the number of processors in the machine or is determined by the value of the OMP_NUM_THREADS environment variable.

Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.

Instructs the compiler to generate an instrumented executable program from the source code under development. The instrumented executable produces feedback data files at runtime using an example dataset. filename specifies the name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented executable "foo". The default is "-fb_create" is disabled.

When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.

Instructs the compiler to perform a feedback directed compilation using the instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not include any instrumentation library calls. Note the same optimization flags specified when creating the instrumented data file with the -fb_create must be specified when invoking the compiler with the -fb_opt option. Otherwise, the compiler will emit checksum errors. The default is "-fb_opt" disabled.

Disables the use of SSE2 instructions. Note disabling SSE2 instructions when specifying -m64 will emit a warning message.

Enables the use of 3DNow instructions.

Enables/disables the use of FMA4 instructions on targets which support them. Specifying "-march=bdver1" enables this option, else the default is "-mno-fma4". Note specifying option "-mno-avx" implies option "-mno-fma4"

Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.

(For C++ only) -fexceptions enables exception handling and thus generates extra code needed to propagate exceptions. -fno-exceptions disables exception handling. Exception handling is enabled by default.

(For C++ only) Enables exception handling, but does not generate code needed to raise/catch exceptions. This option allows the compiler to accept exceptions as part of the C++ dialect but in effect asserts that these exceptions will not actually be raised at runtime.

"-fast-math" instructs the compiler to relax ANSI/ISO or IEEE rules/specifications for math functions in order to optimize floating-point computations to improve runtime. "-fno-fast-math" instructs the compiler to conform to ANSI and IEEE math rules. This option causes the preprocessor macro __FAST_MATH__ to be defined.
Note:
"-Ofast" implies "-ffast-math".
"-ffast-math" sets options "-fno-math-errno" and "-OPT:IEEE_arithmetic=2".
"-fno-fast-math" sets options "-fmath-errno" and "-OPT:IEEE arithmetic=1".

Do not set ERRNO after calling math functions that are executed with a single instruction, e.g. sqrt. A program that relies on IEEE exceptions for math error handling may want to use this flag for speed while maintaining IEEE arithmetic compatibility. Note specifying "-Ofast" implies "-fno-math-errno". The default is "-fmath-errno".

Instructs the compiler to invoke inter-procedural analysis. Specifying "-ipa" is equivalent to "-IPA" and "-IPA:" with no suboptions, thus the default settings for the individual IPA suboptions are used.

Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.

The Code Generation option group -CG: controls the optimizations and transformations of the instruction-level code generator.

-CG:cflow=(on|off|0|1): Specifying OFF disables control flow optimization in code generation. The default is ON.

-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive peephole optimization on compare operations involving memory operands. The default is "CG:cmp_peep=OFF".

-CG:dsched=(on|off|0|1): Instructs the compiler to aggressively schedule operations to maximize throughput during the decode stage of family 15h processors. This flag implies 32-byte alignment by default unless -CG:p2align is set to a value other than 2. The default is "CG:dsched=OFF".

-CG:compute_to=(on|off|0|1): Instructs the compiler to allow local code motion to take advantage of pipeline optimizations. For example: specify in conjunction with option "-march=barcelona", i.e.when targeting versions of the Quad-Core AMD Opteron and greater. The default is "CG:compute_to=OFF"

-CG:cse_regs=N: When performing common subexpression elimination, the compiler code generator assumes that there are N extra integer registers available (i.e. in excess of the number provided by the processor). N can be positive, negative, or zero. The default is positive infinity. See also -CG:sse_cse_regs=N.

-CG:gcm=(on|off|0|1): "-CG:gcm=OFF" instructs the compiler to disable the instruction level global code motion optimization phase. The default is "-CG:gcm=ON".

-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.

-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward direction and once in the backward direction) and take the optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler during compilation.

-CG:locs_shallow_depth=(on|off|0|1): ON instructs the compiler to give priority to instructions that have shallow depths in the dependence graph when performing local instruction scheduling to reduce register usage. The default is "-CG:locs_shallow_depth=OFF".

-CG:movnti=N : When writing memory blocks of size larger than N KB ordinary stores will be transformed into non-temporal stores. The default is N=1000.

-CG:p2align=(on|off|0|1): When ON instructs the compiler to align loop heads to 64-byte boundaries. The default is "-CG:p2align=OFF".

-CG:p2align=(on|off|0|1): When ON forces the compiler to emit multiple nops if alignment needs to be adjusted by more than 8 bytes. The default is "-CG:p2align_split=OFF".

-CG:post_local_sched=(on|off|0|1): When ON, enables the local scheduler phase after register allocation. The default is "-CG:post_local_sched=ON".

-CG:local_sched=(on|off|0|1): When ON, enables the local scheduler. The default is "-CG:local_sched=ON".

-CG:prefetch=(on|off|0|1): With "-CG:prefetch=ON", prefetch instructions are generated in the code generator. Note both "-CG:prefetch=OFF" and "-LNO:prefetch=0" disable the generation of prefetch instructions. "-LNO:prefetch=0" only affects loop-nesting optimizations that rely on prefetch. The default is "-CG:prefetch=ON".

-CG:prefer_legacy_regs=(on|off|0|1): When enabled the compiler register allocator is instructed to use the first 8 integer and SSE registers when possible (i.e. %rax-%rbp, %xmm0-%xmm7). Starting with the last assigned register and work upward in most recently assigned fashion where available. Note instructions which use these registers have smaller instruction sizes. For example, the lower 8 registers on x86-64 do not use the rex byte. The default is "-CG:prefer_legacy_regs=OFF".

-CG:ptr_load_use=N: The code generator increases the modeled latency between an instruction that loads a pointer and an instruction that uses the pointer by N cycles. Ordinarily, it is advantageous to load pointers as fast as possible so the dependent memory instructions can begin execution. However, the additional latency will force the instruction scheduler to schedule the load pointer even earlier. Note the load pointer instructions include load-execute instructions which compute pointer results. The default is "-CG:ptr_load_use=4".

-CG:push_pop_int_saved_regs=(on|off|0|1): When ON, the compiler generates push and pop instructions to save integer callee-saved registers at function prologues and epilogues. The push and pop instructions replace mov instructions to and from memory locations based off the stack pointer. The default is "-CG:push_pop_int_saved_regs=OFF". When the specified target is barcelona, default is "-CG:push_pop_int_saved_regs=ON".

-CG:sse_cse_regs=N: When performing common subexpression elimination, instructs the compiler code generator that there are N extra SSE registers available (i.e. in excess of the number provided by the processor). N can be positive, negative, or zero. The default is positive infinity. See also -CG:cse_regs=N.

-CG:use_prefetchnta=(on|off|0|1): When enabled, prefetching is performed on non-temporal data at all levels of the cache hierarchy. Note this option is for data streaming situations when the data will not need to be reused soon. The default is "-CG:use_prefetchnta=OFF".

-CG:unroll_fb_req=(on|off|0|1): The compiler is instructed to override cold code motion to keep the code generator from adding control flow in unrolled loops. The default is "-CG:unroll_fb_req=OFF".

-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".

The inter-procedural analyzer option group -IPA: controls application of inter-procedural analysis and optimization.

-IPA:callee_limit=N: The compiler is instructed not to allow inlining of functions with a code size larger the limit set by N. The default is "-IPA:callee_limit=500."

-IPA:inline=(on|off): Turns off the IPA's inliner. Since IPA is invoked, the lightweight inliner is also suppressed. The default is ON.

-IPA:linear=(on|off|0|1): The compiler is instructed perform linearization of array references. The compiler transforms a multi-dimensional array to a linear array (i.e. single dimensional)which is mapped to the same memory block. The compiler attempts to map formal array parameters to the shape of the actual parameter when inlining Fortran subroutines. This mapping process may not always be successful, therefore when the compiler is unable to map the parameter it linearizes the array reference. Note the compiler will not attempt to inline such callsites due to possible performance problems. The default is "-IPA:linear=OFF".

-IPA:min_hotness=N: The compiler is instructed not to inline a function to a call site (i.e. caller) unless the callee is invoked more than N times. The compiler examines the interprocedural feedback to determine if the threshold set by N is surpassed by a call site to a procedure and then proceeds to inline the procedure if the limit is exceeded. The default is "-IPA:min_hotness=10".

-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".

-IPA:pu_reorder=(0|1|2): The compiler is instructed to examine compilation feedback for invocation patterns to determine the process of reordering the layout of program procedures in order to minimize instruction cache misses. Possible settings are:

0    Suppress reordering of program procedures.

1    Use the frequent occurrence of procedure invocation to determine reordering.

2    Use the relationship between caller and callee to determine reordering.

The default is "-IPA:pu_reorder=1" for C++ programs and "-IPA:pu_reorder=0" for non-C++ programs.

-IPA:small_pu=N: The compiler is instructed not to restrict a procedure from inlining with a code size smaller than N when invoking the "-IPA:plimit" flag. The default is "-IPA:small_pu=30".

-IPA:space=N: The compiler is instructed to perform inlining until the program code size expands by percentage specified by N. Therefore, to limit program code size growth to ~20%, due to inlining, specify "-IPA:space=20". The default is "-IPA:space=infinity".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:apo_use_feedback=(on|off): Instructs the auto-parallelizer to use the feedback data of the loops in deciding if each loop should be parallelized. This option will only be invoked if "-apo" under feedback-directed compilation has been enabled. The compiler creates a serial and parallel version of a parallelized loop and if the loop trip count is small the serial version is used during execution. When "-LNO:apo_use_feedback=ON" and the feedback data validates that the loop trip count is small the auto-parallelizer will not create the parallel version (i.e. optimizing the runtime by eliminating the conditional code required to determine the use of the serial or parallel version). The default is "-LNO:apo_use_feedback=OFF"

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:full_unroll,fu=N: The compiler is instructed to fully unroll loops after examining the loop, within the loop nest optimizer, to determine if the loop can be fully unrolled in N or less iterations. Argument "fu=N" specifies the maximum number of unrolls that can be performed to fully unroll the loop. Note that setting N=0 suppresses full unrolling of loops inside the loop nest optimizer. The default is "-LNO:full_unroll=5".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:full_unroll_size=N: The compiler is instructed to fully unroll loops after examining the loop, within the loop nest optimizer, to determine if the unrolled loop size is less than or equal to N. Specify N as an integer between 0 and 10000. Note limits set by -LNO:full_unroll,fu=N and -LNO:full_unroll_size=N must be satisfied before the loop is fully unrolled. The default is "-LNO:full_unroll_size=2000."

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:full_unroll_outer=(on|off|0|1): The compiler is instructed to fully unroll loops that do not incorporate inner loops or is incorporated by an outer loop. Note limits set by both "-LNO:full_unroll,fu=N" and "-LNO:full_unroll_size=N" must be satisfied before the loop is fully unrolled. The default is "-LNO:full_unroll_outer=OFF".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:fission=N: Instructs the compiler to perform loop fission. This option can be set to:
0 Suppress loop fission.
1 The compiler performs normal loop fission as necessary.
2 The compiler performs loop fission prior to loop fusion.
Note loop fusion is usually applied before loop fission, therefore if "-LNO:fission=ON" and "-LNO:fusion=ON" when the compiler is invoked a reverse effect may be induced. To counter this effect specify "-LNO:fission=2" to instruct the compiler to perform loop fission prior to loop fusion. The default is "-LNO:fission=0".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:fusion=N: The compiler is instructed to perform loop fusion. The flag can be set to:
0 Suppress loop fusion.
1 The compiler performs traditional loop fusion.
2 The compiler performs aggressive loop fusion.
The default is "-LNO:fusion=0".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:fusion_peeling_limit=N: Controls the limit for the number of iterations allowed to be peeled during fusion. The default is N=5, but N can be any non-negative integer. The compiler performs peeling when the iteration count in consecutive loops is close, but different, and when the loop counts are the same because several iterations are replicated outside the loop body.

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:ignore_feedback=(on|off|0|1): The compiler is instructed to ignore feedback information generated by loop annotations during loop nest optimizations. The default is "-LNO:ignore_feedback=OFF".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:interchange=(on|off|0|1): The compiler is instructed to perform loop interchange optimizations. The default is "-LNO:interchange=ON".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:minvariant,minvar=(on|off|0|1): The compiler is instructed to move loop-invariant expressions outside of loops. The default is "-LNO:minvariant,minvar=ON".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:opt=(0|1): Instructs the compiler at which level to perform loop nest optimizations. The flag can be set to:
0 The compiler is restricted to suppress nearly all loop nest optimizations.
1 The compiler performs full loop nest optimizations.
The default is "-LNO:opt=1"

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:outer_unroll_max,ou_max=N: Instructs the compiler to perform the unrolling of outer loops in a loop nest. The unrolling of the outer loop is limited to N unrolls per outer loop. The default is "-LNO:outer_unroll_max,ou_max=5".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:ou_prod_max=N: The compiler is instructed to unroll several outer loops of a given loop nest. The product is limited to N outer loops. N is a positive number. The default is "-LNO:ou_prod_max=16".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:parallel_overhead=N : Specifying the auto-parallelizing option, "-apo", instructs the compiler to generate a serial and parallel instance of a loop. Specifying -LNO:parallel_overhead. in conjunction with "-apo" instructs the compiler to estimate the overhead involved when invoking the parallel instance of the loop taking into account the number of processors and loop iterations. The loop nest optimizer then uses N to determine if the overhead exceeds the performance benefit during execution time. Note using this flag with auto-parallelizer can be used to tune parallel performance across various platforms and programs. The default is "-LNO:parallel_overhead=4096"

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:prefetch_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=2".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:prefetch=(0|1|2|3) : Instructs the compiler to perform prefetching optimizations at a specified level. The flag can be set to:
0 Instructs the compiler to suppress prefetching.
1 The compiler is instructed to allow prefetching only for arrays that are always referenced in every loop iteration.
2 The compiler is instructed to implement prefetching disregarding the restrictions in the above setting.
3 The compiler is instructed to implement aggressive prefetching.
The default is "-LNO:prefetch=2".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:pf2=(on|off|0|1): The compiler is instructed to turn ON/OFF prefetching for specified cache levels. "pf2" specifies the level 2 cache.

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:sclrze=(on|off): The compiler is instructed to substitute a scalar variable for an array. The default is "-LNO:sclrze=ON".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:simd=(0|1|2|3) : The compiler is instructed to use single instruction multiple data (SIMD) instructions, supported by the target processor, when vectorizing the inner loop. The flag can be set to:
0 The compiler is instructed to suppress vectorization.
1 The compiler is instructed to vectorize only if there is no performance degradation due to sub-optimal alignment and does not induce floating-point operation inaccuracies.
2 Instructs the compiler to aggressively vectorize with no constraints in place.
3 Instructs the compiler to use advanced vectorization techniques such as partial vectorization. This option enables the compiler to vectorize in situations where all parts of a loop may not be vectorizable.
The default is "LNO:simd=1".

Instructs the compiler to enable 128-bit AVX/SSE partial vectorization for loop bodies. In scenarios where there is no loop carried dependence in the input functions, use the option "-LNO:psimd iso unroll=ON" for improved performance. The default is "-LNO:psimd_iso_unroll=OFF".

Instrucuts the compiler to create multiple copies of loops with different alignment assumptions. The compiler adds a runtime test to branch to particular loop when alignment assumptions are met. As necessary, the compiler will peel one or more iterations to improve alignment in alternate loop copies. The default is "-LNO:simd_peel_align=OFF".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:trip_count,trip_count_assumed_when_unknown=N : The compiler is instructed to use the value in N for a presumed loop trip-count if at compile time a loop trip-count is not known. The loop trip-count, N, is used for loop transformations and prefetch optimizations and must be a positive integer. The default is "-LNO:trip_count_assumed_when_unknown,trip_count=1000".

This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".

-LNO:vintr=(0|1|2): The compiler is instructed to use vector intrinsic functions when vectorizing loops. Where a vector function is called once to compute a math intrinsic for the entire vector. The flag can be set to:
0 Instructs the compiler to suppress vector intrinsic function optimizations.
1 The compiler is instructed to perform normal vector intrinsic function optimizations.
2 The compiler is instructed to aggressively implement all vector intrinsic function optimizations. Note specifying this option could cause some of the vector intrinsic functions to produce floating-point accuracy errors.
The default is "-LNO:vintr=1".

Generate code for a 32-bit environment. The 32-bit environment sets int, long and pointer to 32 bits and generates code that runs on any i386 system. The compiler generates x86 or IA32 32-bit ABI. The default on a 32-bit host is 32-bit ABI. The default on a 64-bit host is 64-bit ABI if the target platform specified is 64-bit, otherwise the default is 32-bit.

Generate code for a 64-bit environment. The 64-bit environment sets int to 32 bits and long and pointer to 64 bits and generates code for AMD's x86-64 architecture. The compiler generates AMD64, INTEL64, x86-64 64-bit ABI. The default on a 32-bit host is 32-bit ABI. The default on a 64-bit host is 64-bit ABI if the target platform specified is 64-bit, otherwise the default is 32-bit.

The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.

-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will make assumptions during compilation when one or more of the following <model> is specified:

typed
Assumes that two pointers of different types will not point to the same location in memory (i.e. the code adheres to the ANSI/ISO C standards). Note when specifying "-OPT:Ofast" turns this option ON.

(restricted|restrict)
Assumes that distinct pointers are pointing to distinct non-overlapping objects. The default is that this optimization is disabled.

disjoint
Assumes that any two pointer expressions are pointing to distinct non-overlapping objects. This default is that this optimization is disabled.

^M field_sensitive
^M Replaces the alias algorithm with an alternate implementation that tracks fields of individual pointers, i.e. it is field sensitive. This alternate implementation is also designed to be flow-insensitive, scalable and context-sensitive to heap allocations.

no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are pointing to distinct non-overlapping objects. The default is that this optimization is disabled.

-OPT:div_split=(on|off|0|1)
Instruct the compiler to transform x/y into x*(recip(y)). Flags -OPT:Ofast or -OPT:IEEE_arithmetic=3 will enable this optimization. Note this transform generates fairly accurate code. The default is "-OPT:div_split=OFF".

Instructs the compiler to limit the unrolling of inner loops to the value specified by N. The default is "-OPT:unroll_times_max=4".

Allows expressions of the form 1/X to be changed to use the reciprocal instruction of the computer. This may be faster, but is inherently less accurate than a division.

-OPT:fast_complex=(on|off|0|1)
Specifies fast calculations for values declared to be of the type complex. Fast algorithms are used for complex absolute value and complex division. The algorithm will overflow for an operand (e.g., the divisor in the case of division) that has an absolute value that is larger than the square root of the largest representable floating-point number. Also, the algorithm will underflow for a value that is smaller than the square root of the smallest representable floating point number. Note, specifying "-OPT:roundoff=3" will also invoked "-OPT:fast_complex=ON". The default is "-OPT:fast_complex=OFF".

-OPT:fold_unsigned_relops=(on|off|0|1)
Instructs the compiler to fold relational operators involving unsigned integers that may be simplified at compile time, which may cause fewer overflows to be seen at run time. The default is "-OPT:fold_unsigned_relops=ON".

-OPT:goto=(on|off|0|1)
Transforms GOTO into higher level structures e.g., FOR loops. Note if "-O2" is specified "-OPT:goto=ON". The default is "-OPT:goto=OFF".

-OPT:IEEE_arithmetic,IEEE_arith,IEEE_a=(1|2|3)
This flag regulates the level of conformance to ANSI/IEEE 754- 1985 floating point roundoff and overflow. The levels of conformance:
1 Adhere to IEEE 754 accuracy. Specifying "-O0", "-O1", and "-O2" will set "-OPT:IEEE_arithmetic=1".
2 Inexact results that do not conform to IEEE 754 may be calculated. Specifying "-O3" will set "-OPT:IEEE_arithmetic=2".
3 All mathematically valid transformations (possibly non-IEEE standard ones) are allowed.

-OPT:IEEE_NaN_Inf=(on|off|0|1)
-OPT:IEEE_NaN_inf=ON instructs the compiler to conform to ANSI/IEEE 754-1985 for all operations which produce a NaN or infinity result. Note NaN and infinity are typically handled as special cases in floating-point representations of real numbers and are defined by the IEEE 754 Standards for Binary Floating-point Arithmetic. The default is "-OPT:IEEE_NaN_Inf=ON".
-OPT:IEEE_NaN_inf=OFF instructs the compiler to calculate various operations that do not produce IEEE-754 results. For example, x/x is set to the value 1 without performing a divide operation and x=x is set to TRUE with out executing a test operation. "-OPT:IEEE_NaN_inf=OFF" specifies multiple optimizations that increase performance.

-OPT:keep_ext=(on|off|0|1)
Instructs the compiler to preserve external symbolic information. The default is "-OPT:keep_ext=OFF".

-OPT:malloc_algorithm,malloc_alg=(0|1|2)
To improve runtime speed the compiler will select an optimal malloc algorithm. To enable the selected algorithm, setup code is included in the C/C++ and Fortran main function.

• n=0: Default, no changes to the malloc options. No call to mallopt() is made.
• n=1: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x10000000. Call mallopt with the two settings.
• n=2: M_MMAP_MAX=2 and M_TRIM_THRESHOLD=0x40000000. Call mallopt with the two settings.

The two parameters, M_MMAP_MAX and M_TRIM_THRESHOLD, are described below.

Function: int mallopt (int param, int value) When calling mallopt, the param argument specifies the parameter to be set, and value the new value to be set. Possible choices for param, as defined in malloc.h, are:

• M_MMAP_MAX The maximum number of chunks to allocate with mmap. Setting this to zero disables all use of mmap.
• M_TRIM_THRESHOLD This is the minimum size (in bytes) of the top-most, releasable chunk that will cause sbrk to be called with a negative argument in order to return memory to the system.

-OPT:Ofast
Maximizes performance for a given platform using the selected optimizations. "-OPT:Ofast" specifies four optimizations; "-OPT:ro=2", "-OPT:Olimit=0", "-OPT:div_split=ON", and "-OPT:alias=typed". Note the specified optimizations are ordinarily safe but floating point accuracy due to transformations may be diminished.

-OPT:Olimit=N
Controls the size of procedures to be optimized. Procedures above the specified cutoff limit, N, are not optimized. N=0 means "infinite Olimit", which causes all procedures to be optimized with no consideration regarding compilation times. Note if "-OPT:Ofast" is enabled then "-OPT:Olimit=0" or when "-O3" is enabled "-OPT:Olimit=9000". The default is "-OPT:Olimit=6000".

-OPT:roundoff,ro=(0|1|2|3)
"-OPT:roundoff" specifies acceptable levels of divergence for both accuracy and overflow/underflow behavior of floating-point results relative to the source language rules. The roundoff value is in the range 0-3 with each value described as follows:
0 Do no transformations which could affect floating-point results. The default for optimization levels "-O0", "-O1", and "-O2".
1 Allow all transformations which have a limited affect on floating-point results. For roundoff, limited is defined as only the last bit or two of the mantissa is affected. For overflow or underflow, limited is defined as intermediate results of the transformed calculation may overflow or underflow within a factor of two of where the original expression may have overflowed or underflowed. Note that effects may be less limited when compounded by multiple transformations. This is the default when "-O3" is specified.
2 Specifies transformations with extensive effects on floating-point results. For example, allow associative rearrangement (i.e. even across loop iterations) and the distribution of multiplication over addition or subtraction. Do not specify transformations known to cause: a. cumulative roundoff errors, or b. overflow/underflow of operands in a large range of valid floating-point values. This is the default when specifying "-OPT:Ofast".
3 Specify any mathematically valid transformation of floating-point expressions. For example, floating point induction variables in loops are permitted (even if known to cause cumulative roundoff errors). Also permitted are fast algorithms for complex absolute value and divide (which will overflow/underflow for operands beyond the square root of the representable extremes).

-OPT:rsqrt=(0|1|2)
Instructs the compiler to use the reciprocal square root instruction when calculating the square root. This transformation may vary the accuracy slightly.
0 Restrain from using the reciprocal square root instruction.
1 Use the reciprocal square root instruction followed by operations that will improve the accuracy of the results.
2 Use the reciprocal square root instruction without improving the result accuracy.
Note "-OPT:rsqrt=1" if "-OPT:roundoff=2" or "-OPT:roundoff=3". The default is "-OPT:rsqrt=0".

-OPT:treeheight=(on|off|0|1)
Instructs the compiler to perform a global reassociation of expressions which reduces the tree height of the expressions. The reassociation process determines the optimum order of combining terms in a sum so as to produce loop invariant subcomputations or to refine common subexpressions among several essential computations. The default is "-OPT:treeheight=OFF".

-OPT:unroll_level=(1|2)
Controls the level at which the compiler will perform unrolling optimizations. When "-OPT:unroll_level=2" the compiler is instructed to aggressively unroll loops in the presence of control flow. The default is "-OPT:unroll_level=1".

-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced when unrolling inner loops. When N=0 the ceiling is disregarded. Note by specifying "-O3" sets "-OPT:unroll_size=128". The default is "-OPT:unroll_size=40".

-OPT:unroll_times_max=N
Instructs the compiler to limit the unrolling of inner loops to the value specified by N. The default is "-OPT:unroll_times_max=4".

-L<library directory> -lsmartheap ,
when used as an EXTRA_CXXLIB variable, results in linking with MicroQuill's SmartHeap 8 (32-bit) library for Linux. This is a library that optimizes calls to new, delete, malloc and free.

-static
On systems that support dynamic linking, this prevents linking with shared libraries. On other systems, this option has no effect.

This group of options controls the affect the global optimizer has on the program. "-WOPT:" only influences global optimizations specified by "-O2" or above.

-WOPT:aggstr=N
-WOPT:aggstr regulates the aggressiveness of the compilers scalar optimizer when performing strength reduction optimizations. Strength reduction is the substitution of induction expressions within a loop with temporaries that are incremented together with the loop variable. The value N specifies the maximum number of induction expressions being replaced. Select positive integers only for variable N. Setting N=0 tells the scalar optimizer to use strength reduction for non-trivial induction expressions. Note specifying very aggressive strength reductions may prompt additional temporaries increasing register pressure and resulting in excessive register spills that decrease performance. The default is "-WOPT:aggstr=11".

-WOPT:if_conv=(0|1|2):
"-WOPT:if_conv" instructs the compiler to transform simple IF statements to conditional move instructions. "-WOPT:if_conv" has three settings:
0 Disables this optimization.
1 Specifies conservative IF statement transformations. The context surrounding the IF statement is used in the transformation decision.
2 Use aggressive IF statement transformations. Perform the IF statement transformation regardless of the surrounding context.
The default is "-WOPT:if_conv=1".

The compiler's scalar optimizer is instructed to take advantage of scaled-index addressing mode. For example if "-WOPT:sib" is set, strength reduction will be performed less aggressively. The default is "-WOPT:sib=OFF".

-WOPT:mem_opnds=(on|off|0|1)
The compilers scalar optimizer is instructed to use automated reasoning to protect all memory operands of arithmetic operations. The process attempts to incorporate memory loads as part of the operands of arithmetic operations (e.g., the compiler tries to combine a memory load and an arithmetic instruction into one instruction). The default is "WOPT:mem_opnds=OFF".

-WOPT:unroll=(0|1|2) : Specifying "WOPT:unroll" helps regulate the compiler's scalar optimizer when unrolling of innermost loops. The available settings are:
0 Innermost loop unrolling is suppressed.
1 Instructs the compilers scalar optimizer to unroll the innermost loops which contain IF statements. Selecting this setting compliments the loop unrolling performed in the code generator.
2 Instructs the compiler's scalar optimized to unroll the innermost loops which contain straight line code plus the loops containing IF statements. Selecting this setting duplicates the unrolling performed in the code generator (i.e. unrolling straight line code in the body of a loop).
Note "-WOPT:unroll" and the unrolling options in the "-OPT" group are mutually exclusive. The default is "-WOPT:unroll=1".

Global register allocation (GRA) is the process of multiplexing a large number of target program variables onto a small number of CPU registers. The code generator implements global register allocation when certain optimization levels are specified.

-GRA:optimize_boundary=(on|off|0|1)
Instructs the compiler to permit the register allocator to assign the same register to different variables in the same basic-block. The default is "-GRA:optimize_boundary=OFF".

-GRA:prioritize_by_density=(on|off|0|1)
Instructs the compiler's Global Register Allocator (GRA) to prioritize register assignments to variables based on the variables' reference count density (number of times the variables are referenced in a local region of interest) and not on their global reference count. The default is "-GRA:prioritize_by_density=OFF".

-GRA:unspill=(on|off|0|1)
Instructs the compiler's Global Register Allocator (GRA) to aggressively remove redundant register spills that occur in the boundary region between GRA and LRA (Local Register Allocator). The default is "-GRA:unspill=off".

Options in the -LANG: group can be used to control the set of features that are supported. For example, to compile code that does not conform with the standard in one way or another. Note it may not always be possible, however, to link together object files, some of which have been compiled with a feature enabled and others with it disabled.

-LANG:copyinout=(on|off)
If an array section is passed as an argument in a call, the compiler is instructed to copy the array section into a temporary array that will be passed as the argument in the call. -LANG:copyinout optimizes the accessing of array arguments by improving argument locality. Note the flag helps regulate the aggressiveness of this optimization and is mainly suited to Fortran code. When specifying global optimization -O2 or higher -LANG:copyinout=ON. The default is "-LANG:copyinout=OFF".

-LANG:heap_allocation_threshold=N
Specifies the threshold when determining whether to allocate an automatic array or compiler temporary on the heap rather than on the stack. Parameter size is in bytes and sets the threshold. Setting size to -1 implies all objects are placed on the stack. Setting size to 0 implies all objects are placed on the heap. The default is "-LANG:heap_allocation_threshold=-1" for maximum performance.

These -TENV: options control the target environment assumed and/or produced by the compiler.

-TENV:frame_pointer=(on|off)
Setting this option to ON tells the compiler to use the frame pointer register to address local variables in the function stack frame. Generally, if the compiler determines that the stack pointer is fixed it will use the stack pointer to address local variables throughout the function invocation in place of the frame pointer. This frees up the frame pointer for other purposes. The default is ON for C/C++ and OFF for Fortran. This flag defaults to ON for C/C++ because the exception handling mechanism relies on the frame pointer register being used to address local variables. This flag can be turned OFF for C/C++ programs that do not generate exceptions.

When enabled, the code generator uses an additional prescheduling algorithm for minimizing register pressure. With "-CG:pre_minreg_level=1" the prescheduling algorithm is applied globally to all basic blocks and will apply only when more registers are requested than the maximum physical registers. With "-CG:pre_minreg_level=" the prescheduling algorithm is also invoked, but only to unrolled loops. The default is to not use either heuristic.

When on, enables the local scheduler phase before register allocation. The default is "-CG:pre_local_sched=on".

Invokes a local optimization where integer expressions of |a % b| when b is a power of two and b is greater than 0, are replaced with |if (a > 0) a & (b-1) else (a % b)|. The default is "-CG:divrem_opt=off".

When enabled the local instruction scheduler is run several times using different heuristics. The optimal schedule generated is selected. Note this option supersedes options which control local instruction scheduling, e.g. "-CG:local_sched_alg" and "-CG:locs_shallow_depth". The default is "-CG:locs_best=off".

The compiler is instructed to perform outer loop vectorization by moving vectorizable loop into the innermost position. The default is "-LNO:loop_model_simd=off".

The compiler is instructed to remove the remainder loop construct for the vectorized loops. The default is "-LNO:simd_rm_unity_remainder=off".

Instructs the compiler to perform array copying to improve data cache utilization. The flag can be set to: 0 Instructs the compiler to suppress array copying. 1 Instructs the compiler to perform limited array copying. 2 Instructs the compiler to aggressively perform array copying. The default is "-OPT:struct_array_copy=1".

-OPT:roundoff=(0|1|2|3)
"-OPT:roundoff" specifies acceptable levels of divergence for both accuracy and overflow/underflow behavior of floating-point results relative to the source language rules. The roundoff value has a value in the range 0 to 3 and are described in the following table: 0 Do *no* transformations which could affect floating-point results. The is the default for optimization levels "-O0", "-O1", and "-O2". 1 Allow all transformations which have a limited affect on floating-point results. For roundoff, limited is defined as only the last bit or two of the mantissa is affected. For overflow or underflow, limited is defined as intermediate results of the transformed calculation may overflow or underflow within a factor of two where the original expression may have overflowed or underflowed. Note that effects may be less limited when compounded by multiple transformations. This is the default when "-O3" is specified. 2 Specifies transformations with extensive effects on floating-point results. For example, allow associative rearrangement (i.e. even across loop iterations) and the distribution of multiplication over addition or subtraction. Do *not* specify transformations known to cause: * - cumulative roundoff errors. * - overflow/underflow of operands in a large range of valid floating-point values. This is the default when specifying "-OPT:Ofast" or "-O3" 3 Specify any mathematically valid transformation of floating-point expressions. For example, floating point induction variables in loops are permitted (even if known to cause cumulative roundoff errors). Also permitted are fast algorithms for complex absolute value and divide (which will overflow/underflow for operands beyond the square root of the representable extremes).

-CG:use_incdec=(on|off) toggles a code generator based peephole optimization which modifies add|sub instructions which utilize immediate fields and for which the value for that immediate is +/- 1 into inc/dec instructions. This optimization decreases code size by emitting instructions with fewer bytes on x86 architectures. The default option is "=CG:use_incdec=on".

The compiler is instructed to optimize move extend or load extend instructions when followed by compare instructions. The default is "-CG:movext_icmp=on".

Instructs the code generator to perform optimizations on interior array indices that have arbitrary offset distances not known at compile time. The code generator uses multiple versions of loops to determine at runtime the best loop. This flag also turns on "-CG:merge_counters_x86". The default is "-CG:interior_ptrs=off".

Instructs the compiler to throttle the aggressiveness of speculative code motion optimization. This flag has the following three settings: 0 Disable speculative code motion. 1 Allow speculative code motion, but only in situations where it is deemed profitable (i.e., in cases where register pressure is not too high). 2 Allow speculative code motion even in cases where the register pressure may be too high. The default is "-WOPT:aggcm=1".

Instructs the compiler to perform loop transformations by using library function calls to |memcpy| or |memset|. The default is "-OPT:transform=1".

Instructs the compiler to use a more efficient STL set map implementation. This allows faster iterations over sets and maps. This option is currently available only on open64 compilers downloaded from AMD.

Instructs the compiler's GRA to perform aggressive loop splitting. This feature is on by default and can be disabled through "-GRA:aggr_loop_splitting=OFF"

Instructs the compiler to perform loop splitting. This feature is on by default.

Instructs the compiler to convert simple if-conditions with direct/indirect stores within loops to "Select" statements, thereby removing control flow and enabling vectorization. This feature is off by default.

CFP2006:

If -funderscoring is in effect, and the original Fortran external identifier contained an underscore, -fsecond-underscore appends a second underscore to the one added by -funderscoring. -fno-second-underscore does not append a second underscore. The default is both -funderscoring and -fsecond-underscore, the same defaults as g77 uses. -fno-second-underscore corresponds to the default policies of PGI Fortran and Intel Fortran.

Invoke the Open64 C compiler.
Also used to invoke linker for C programs.

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

Invoke the Open64 Fortran 77, 90 and 95 compilers.
Also used to invoke linker for Fortran programs and for mixed C / Fortran. openf90 and openf95 are synonymous.

-IPA:max_jobs=N: The compiler is instructed to limit the number of compilations running at once to N. After interprocedural analysis is performed the compiler is invoked with -IPA:max_jobs set to the maximum level of parallelism. N can be set to:
0 The maximum level of parallelism is limited to the greatest number of CPUs (or processor sockets), processor cores, or hyperthreading units in the system.
1 Suppress parallelization during compilation.
>=2 Sets the desired level of parallelism.
The default is "-IPA:max_jobs=1".