These options control various sorts of optimizations.
Without any optimization option, the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you expect from the source code.
Turning on optimization flags makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program.
The compiler performs optimization based on the knowledge it has of the program. Compiling multiple files at once to a single output file mode allows the compiler to use information gained from all of the files when compiling each of them.
Not all optimizations are controlled directly by a flag. Only optimizations that have a flag are listed in this section.
Most optimizations are only enabled if an -O level is set on the command line. Otherwise they are disabled, even if individual optimization flags are specified.
Depending on the target and how GCC was configured, a slightly different set of optimizations may be enabled at each -O level than those listed here. You can invoke GCC with -Q --help=optimizers to find out the exact set of optimizations that are enabled at each level. See Overall Options, for examples.
-O-O1With -O, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time.
-O turns on the following optimization flags:
-fauto-inc-dec -fcompare-elim -fcprop-registers -fdce -fdefer-pop -fdelayed-branch -fdse -fguess-branch-probability -fif-conversion2 -fif-conversion -fipa-pure-const -fipa-profile -fipa-reference -fmerge-constants -fsplit-wide-types -ftree-bit-ccp -ftree-builtin-call-dce -ftree-ccp -ftree-ch -ftree-copyrename -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-forwprop -ftree-fre -ftree-phiprop -ftree-slsr -ftree-sra -ftree-pta -ftree-ter -funit-at-a-time
-O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging.
-O2-O, this option increases both compilation time and the performance of the generated code. -O2 turns on all optimization flags specified by -O. It also turns on the following optimization flags:
-fthread-jumps -falign-functions -falign-jumps -falign-loops -falign-labels -fcaller-saves -fcrossjumping -fcse-follow-jumps -fcse-skip-blocks -fdelete-null-pointer-checks -fdevirtualize -fdevirtualize-speculatively -fexpensive-optimizations -fgcse -fgcse-lm -fhoist-adjacent-loads -finline-small-functions -findirect-inlining -fipa-sra -fisolate-erroneous-paths-dereference -foptimize-sibling-calls -fpartial-inlining -fpeephole2 -freorder-blocks -freorder-functions -frerun-cse-after-loop -fsched-interblock -fsched-spec -fschedule-insns -fschedule-insns2 -fstrict-aliasing -fstrict-overflow -ftree-switch-conversion -ftree-tail-merge -ftree-pre -ftree-vrp
Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos.
-O3-O3 turns on all optimizations specified by -O2 and also turns on the -finline-functions, -funswitch-loops, -fpredictive-commoning, -fgcse-after-reload, -ftree-loop-vectorize, -ftree-slp-vectorize, -fvect-cost-model, -ftree-partial-pre and -fipa-cp-clone options. -O0-Os-Os enables all -O2 optimizations that do not typically increase code size. It also performs further optimizations designed to reduce code size. -Os disables the following optimization flags:
-falign-functions -falign-jumps -falign-loops -falign-labels -freorder-blocks -freorder-blocks-and-partition -fprefetch-loop-arrays
-Ofast-Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math and the Fortran-specific -fno-protect-parens and -fstack-arrays. -Og-Og enables optimizations that do not interfere with debugging. It should be the optimization level of choice for the standard edit-compile-debug cycle, offering a reasonable level of optimization while maintaining fast compilation and a good debugging experience. If you use multiple -O options, with or without level numbers, the last such option is the one that is effective.
Options of the form -fflag specify machine-independent flags. Most flags have both positive and negative forms; the negative form of -ffoo is -fno-foo. In the table below, only one of the forms is listed—the one you typically use. You can figure out the other form by either removing ‘no-’ or adding it.
The following options control specific optimizations. They are either activated by -O options or are related to ones that are. You can use the following flags in the rare cases when “fine-tuning” of optimizations to be performed is desired.
-fno-defer-popDisabled at levels -O, -O2, -O3, -Os.
-fforward-propagateThis option is enabled by default at optimization levels -O, -O2, -O3, -Os.
-ffp-contract=style
-ffp-contract=off disables floating-point expression contraction. -ffp-contract=fast enables floating-point expression contraction such as forming of fused multiply-add operations if the target has native support for them. -ffp-contract=on enables floating-point expression contraction if allowed by the language standard. This is currently not implemented and treated equal to -ffp-contract=off. The default is -ffp-contract=fast.
-fomit-frame-pointerOn some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn't exist. The machine-description macro FRAME_POINTER_REQUIRED controls whether a target machine supports this flag. See Register Usage.
Starting with GCC version 4.6, the default setting (when not optimizing for size) for 32-bit GNU/Linux x86 and 32-bit Darwin x86 targets has been changed to -fomit-frame-pointer. The default can be reverted to -fno-omit-frame-pointer by configuring GCC with the --enable-frame-pointer configure option.
Enabled at levels -O, -O2, -O3, -Os.
-foptimize-sibling-callsEnabled at levels -O2, -O3, -Os.
-fno-inlinealways_inline attribute. This is the default when not optimizing. Single functions can be exempted from inlining by marking them with the noinline attribute.
-finline-small-functionsEnabled at level -O2.
-findirect-inlining-finline-functions or -finline-small-functions options. Enabled at level -O2.
-finline-functionsIf all calls to a given function are integrated, and the function is declared static, then the function is normally not output as assembler code in its own right.
Enabled at level -O3.
-finline-functions-called-oncestatic functions called once for inlining into their caller even if they are not marked inline. If a call to a given function is integrated, then the function is not output as assembler code in its own right. Enabled at levels -O1, -O2, -O3 and -Os.
-fearly-inliningalways_inline and functions whose body seems smaller than the function call overhead early before doing -fprofile-generate instrumentation and real inlining pass. Doing so makes profiling significantly cheaper and usually inlining faster on programs having large chains of nested wrapper functions. Enabled by default.
-fipa-sraEnabled at levels -O2, -O3 and -Os.
-finline-limit=n
Inlining is actually controlled by a number of parameters, which may be specified individually by using --param name=value. The -finline-limit=n option sets some of these parameters as follows:
max-inline-insns-singlemax-inline-insns-autoSee below for a documentation of the individual parameters controlling inlining and for the defaults of these parameters.
Note: there may be no value to -finline-limit that results in default behavior.
Note: pseudo instruction represents, in this particular context, an abstract measurement of function's size. In no way does it represent a count of assembly instructions and as such its exact meaning might change from one release to an another.
-fno-keep-inline-dllexport-fkeep-inline-functions, which applies only to functions that are declared using the dllexport attribute or declspec (See Declaring Attributes of Functions.) -fkeep-inline-functionsstatic functions that are declared inline into the object file, even if the function has been inlined into all of its callers. This switch does not affect functions using the extern inline extension in GNU C90. In C++, emit any and all inline functions into the object file. -fkeep-static-constsstatic const when optimization isn't turned on, even if the variables aren't referenced. GCC enables this option by default. If you want to force the compiler to check if a variable is referenced, regardless of whether or not optimization is turned on, use the -fno-keep-static-consts option.
-fmerge-constantsThis option is the default for optimized compilation if the assembler and linker support it. Use -fno-merge-constants to inhibit this behavior.
Enabled at levels -O, -O2, -O3, -Os.
-fmerge-all-constantsThis option implies -fmerge-constants. In addition to -fmerge-constants this considers e.g. even constant initialized arrays or initialized constant variables with integral or floating-point types. Languages like C or C++ require each variable, including multiple instances of the same variable in recursive calls, to have distinct locations, so using this option results in non-conforming behavior.
-fmodulo-sched-fmodulo-sched-allow-regmoves-fmodulo-sched enabled. -fno-branch-count-regThe default is -fbranch-count-reg.
-fno-function-cseThis option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used.
The default is -ffunction-cse
-fno-zero-initialized-in-bssThis option turns off this behavior because some programs explicitly rely on variables going to the data section—e.g., so that the resulting executable can find the beginning of that section and/or make assumptions based on that.
The default is -fzero-initialized-in-bss.
-fthread-jumpsEnabled at levels -O2, -O3, -Os.
-fsplit-wide-typeslong
long on a 32-bit system, split the registers apart and allocate them independently. This normally generates better code for those types, but may make debugging more difficult. Enabled at levels -O, -O2, -O3, -Os.
-fcse-follow-jumpsif statement with an else clause, CSE follows the jump when the condition tested is false. Enabled at levels -O2, -O3, -Os.
-fcse-skip-blocks-fcse-follow-jumps, but causes CSE to follow jumps that conditionally skip over blocks. When CSE encounters a simple if statement with no else clause, -fcse-skip-blocks causes CSE to follow the jump around the body of the if. Enabled at levels -O2, -O3, -Os.
-frerun-cse-after-loopEnabled at levels -O2, -O3, -Os.
-fgcseNote: When compiling a program using computed gotos, a GCC extension, you may get better run-time performance if you disable the global common subexpression elimination pass by adding -fno-gcse to the command line.
Enabled at levels -O2, -O3, -Os.
-fgcse-lm-fgcse-lm is enabled, global common subexpression elimination attempts to move loads that are only killed by stores into themselves. This allows a loop containing a load/store sequence to be changed to a load outside the loop, and a copy/store within the loop. Enabled by default when -fgcse is enabled.
-fgcse-sm-fgcse-sm is enabled, a store motion pass is run after global common subexpression elimination. This pass attempts to move stores out of loops. When used in conjunction with -fgcse-lm, loops containing a load/store sequence can be changed to a load before the loop and a store after the loop. Not enabled at any optimization level.
-fgcse-las-fgcse-las is enabled, the global common subexpression elimination pass eliminates redundant loads that come after stores to the same memory location (both partial and full redundancies). Not enabled at any optimization level.
-fgcse-after-reload-fgcse-after-reload is enabled, a redundant load elimination pass is performed after reload. The purpose of this pass is to clean up redundant spilling. -faggressive-loop-optimizations-funsafe-loop-optimizations-Wunsafe-loop-optimizations, the compiler warns you if it finds this kind of loop. -fcrossjumpingEnabled at levels -O2, -O3, -Os.
-fauto-inc-dec-O and higher on architectures that support this. -fdce-O and higher. -fdse-O and higher. -fif-conversionif-conversion2. Enabled at levels -O, -O2, -O3, -Os.
-fif-conversion2Enabled at levels -O, -O2, -O3, -Os.
-fdeclone-ctor-dtorEnabled by -Os.
-fdelete-null-pointer-checksNote however that in some environments this assumption is not true. Use -fno-delete-null-pointer-checks to disable this optimization for programs that depend on that behavior.
Some targets, especially embedded ones, disable this option at all levels. Otherwise it is enabled at all levels: -O0, -O1, -O2, -O3, -Os. Passes that use the information are enabled independently at different optimization levels.
-fdevirtualize-findirect-inlining) and interprocedural constant propagation (-fipa-cp). Enabled at levels -O2, -O3, -Os. -fdevirtualize-speculatively-fexpensive-optimizationsEnabled at levels -O2, -O3, -Os.
-freeEnabled for Alpha, AArch64 and x86 at levels -O2, -O3, -Os.
-fno-lifetime-dse-flive-range-shrinkage-fira-algorithm=algorithm
priority’, which specifies Chow's priority coloring, or ‘CB’, which specifies Chaitin-Briggs coloring. Chaitin-Briggs coloring is not implemented for all architectures, but for those targets that do support it, it is the default because it generates better code. -fira-region=region
all’mixed’-O, -O2, ...). one’-Os or -O0. -fira-hoist-pressureThis option is enabled at level -Os for all targets.
-fira-loop-pressureThis option is enabled at level -O3 for some targets.
-fno-ira-share-save-slots-fno-ira-share-spill-slots-fira-verbose=n
-fdelayed-branchEnabled at levels -O, -O2, -O3, -Os.
-fschedule-insnsEnabled at levels -O2, -O3.
-fschedule-insns2-fschedule-insns, but requests an additional pass of instruction scheduling after register allocation has been done. This is especially useful on machines with a relatively small number of registers and where memory load instructions take more than one cycle. Enabled at levels -O2, -O3, -Os.
-fno-sched-interblock-fschedule-insns or at -O2 or higher. -fno-sched-spec-fschedule-insns or at -O2 or higher. -fsched-pressure-fschedule-insns or at -O2 or higher. Usage of this option can improve the generated code and decrease its size by preventing register pressure increase above the number of available hard registers and subsequent spills in register allocation. -fsched-spec-load-fschedule-insns or at -O2 or higher. -fsched-spec-load-dangerous-fschedule-insns or at -O2 or higher. -fsched-stalled-insns-fsched-stalled-insns=n
-fno-sched-stalled-insns means that no insns are moved prematurely, -fsched-stalled-insns=0 means there is no limit on how many queued insns can be moved prematurely. -fsched-stalled-insns without a value is equivalent to -fsched-stalled-insns=1. -fsched-stalled-insns-dep-fsched-stalled-insns-dep=n
-fsched-stalled-insns is used. -fno-sched-stalled-insns-dep is equivalent to -fsched-stalled-insns-dep=0. -fsched-stalled-insns-dep without a value is equivalent to -fsched-stalled-insns-dep=1. -fsched2-use-superblocksThis only makes sense when scheduling after register allocation, i.e. with -fschedule-insns2 or at -O2 or higher.
-fsched-group-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -fsched-critical-path-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -fsched-spec-insn-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -fsched-rank-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -fsched-last-insn-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -fsched-dep-count-heuristic-fschedule-insns or -fschedule-insns2 or at -O2 or higher. -freschedule-modulo-scheduled-loops-fselective-scheduling-fselective-scheduling2-fsel-sched-pipelining-fselective-scheduling or -fselective-scheduling2 is turned on. -fsel-sched-pipelining-outer-loops-fsel-sched-pipelining is turned on. -fshrink-wrap-O and higher. -fcaller-savesThis option is always enabled by default on certain machines, usually those which have no call-preserved registers to use instead.
Enabled at levels -O2, -O3, -Os.
-fcombine-stack-adjustmentsEnabled by default at -O1 and higher.
-fconserve-stacklarge-stack-frame parameter to 100 and the large-stack-frame-growth parameter to 400. -ftree-reassoc-O and higher. -ftree-pre-O2 and -O3. -ftree-partial-pre-O3. -ftree-forwprop-O and higher. -ftree-fre-O and higher. -ftree-phiprop-O and higher. -fhoist-adjacent-loads-O2 and higher. -ftree-copy-prop-O and higher. -fipa-pure-const-O and higher. -fipa-reference-O and higher. -fipa-pta-fipa-profilecold, noreturn, static constructors or destructors) are identified. Cold functions and loop less parts of functions executed once are then optimized for size. Enabled by default at -O and higher. -fipa-cp-O2, -Os and -O3. -fipa-cp-clone-O3. -fisolate-erroneous-paths-dereference-fisolate-erroneous-paths-attributereturns_nonnull or nonnull attribute. Isolate those paths from the main control flow and turn the statement with erroneous or undefined behaviour into a trap. This is not currently enabled, but may be enabled by -O2 in the future. -ftree-sink-O and higher. -ftree-bit-ccp-O and higher. It requires that -ftree-ccp is enabled. -ftree-ccp-O and higher. -ftree-switch-conversion-O2 and higher. -ftree-tail-merge-O2 and higher. The compilation time in this pass can be limited using max-tail-merge-comparisons parameter and max-tail-merge-iterations parameter. -ftree-dce-O and higher. -ftree-builtin-call-dceerrno but are otherwise side-effect free. This flag is enabled by default at -O2 and higher if -Os is not also specified. -ftree-dominator-opts-O and higher. -ftree-dse-O and higher. -ftree-ch-O and higher. It is not enabled for -Os, since it usually increases code size. -ftree-loop-optimize-O and higher. -ftree-loop-linear-floop-interchange. To use this code transformation, GCC has to be configured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure. -floop-interchangeDO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
ENDDO
ENDDO loop interchange transforms the loop as if it were written:
DO I = 1, N
DO J = 1, M
A(J, I) = A(J, I) * C
ENDDO
ENDDO which can be beneficial when N is larger than the caches, because in Fortran, the elements of an array are stored in memory contiguously by column, and the original loop iterates over rows, potentially creating at each access a cache miss. This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be configured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure.
-floop-strip-mineloop-block-tile-size parameter. For example, given a loop like: DO I = 1, N A(I) = A(I) + C ENDDO
loop strip mining transforms the loop as if it were written:
DO II = 1, N, 51
DO I = II, min (II + 50, N)
A(I) = A(I) + C
ENDDO
ENDDO This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be configured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure.
-floop-blockloop-block-tile-size parameter. For example, given a loop like: DO I = 1, N
DO J = 1, M
A(J, I) = B(I) + C(J)
ENDDO
ENDDO loop blocking transforms the loop as if it were written:
DO II = 1, N, 51
DO JJ = 1, M, 51
DO I = II, min (II + 50, N)
DO J = JJ, min (JJ + 50, M)
A(J, I) = B(I) + C(J)
ENDDO
ENDDO
ENDDO
ENDDO which can be beneficial when M is larger than the caches, because the innermost loop iterates over a smaller amount of data which can be kept in the caches. This optimization applies to all the languages supported by GCC and is not limited to Fortran. To use this code transformation, GCC has to be configured with --with-ppl and --with-cloog to enable the Graphite loop transformation infrastructure.
-fgraphite-identity-fgraphite-identity we can check the costs or benefits of the GIMPLE -> GRAPHITE -> GIMPLE transformation. Some minimal optimizations are also performed by the code generator CLooG, like index splitting and dead code elimination in loops. -floop-nest-optimize-floop-parallelize-all-fcheck-data-deps-ftree-loop-if-convert-ftree-loop-if-convert-storesfor (i = 0; i < N; i++)
if (cond)
A[i] = expr; is transformed to
for (i = 0; i < N; i++) A[i] = cond ? expr : A[i];
potentially producing data races.
-ftree-loop-distributionDO I = 1, N A(I) = B(I) + C D(I) = E(I) * F ENDDO
is transformed to
DO I = 1, N A(I) = B(I) + C ENDDO DO I = 1, N D(I) = E(I) * F ENDDO
-ftree-loop-distribute-patterns-O3. This pass distributes the initialization loops and generates a call to memset zero. For example, the loop
DO I = 1, N A(I) = 0 B(I) = A(I) + I ENDDO
is transformed to
DO I = 1, N A(I) = 0 ENDDO DO I = 1, N B(I) = A(I) + I ENDDO
and the initialization loop is transformed into a call to memset zero.
-ftree-loop-im-funswitch-loops it also moves operands of conditions that are invariant out of the loop, so that we can use just trivial invariantness analysis in loop unswitching. The pass also includes store motion. -ftree-loop-ivcanon-fivopts-ftree-parallelize-loops=n-pthread, and thus is only supported on targets that have support for -pthread. -ftree-pta-O and higher. -ftree-sra-O and higher. -ftree-copyrename-O and higher. -ftree-coalesce-inlined-vars-ftree-copyrename) to attempt to combine small user-defined variables too, but only if they were inlined from other functions. It is a more limited form of -ftree-coalesce-vars. This may harm debug information of such inlined variables, but it will keep variables of the inlined-into function apart from each other, such that they are more likely to contain the expected values in a debugging session. This was the default in GCC versions older than 4.7. -ftree-coalesce-vars-ftree-copyrename) to attempt to combine small user-defined variables too, instead of just compiler temporaries. This may severely limit the ability to debug an optimized program compiled with -fno-var-tracking-assignments. In the negated form, this flag prevents SSA coalescing of user variables, including inlined ones. This option is enabled by default. -ftree-ter-O and higher. -ftree-slsr-O and higher. -ftree-vectorize-ftree-loop-vectorize and -ftree-slp-vectorize if not explicitly specified. -ftree-loop-vectorize-O3 and when -ftree-vectorize is enabled. -ftree-slp-vectorize-O3 and when -ftree-vectorize is enabled. -fvect-cost-model=model
unlimited, dynamic or cheap. With the unlimited model the vectorized code-path is assumed to be profitable while with the dynamic model a runtime check will guard the vectorized code-path to enable it only for iteration counts that will likely execute faster than when executing the original scalar loop. The cheap model will disable vectorization of loops where doing so would be cost prohibitive for example due to required runtime checks for data dependence or alignment but otherwise is equal to the dynamic model. The default cost model depends on other optimization flags and is either dynamic or cheap. -fsimd-cost-model=model
unlimited, dynamic, cheap. All values of model have the same meaning as described in -fvect-cost-model and by default a cost model defined with -fvect-cost-model is used. -ftree-vrp-O2 and higher. Null pointer check elimination is only done if -fdelete-null-pointer-checks is enabled. -ftracer-funroll-loops-funroll-loops implies -frerun-cse-after-loop. This option makes code larger, and may or may not make it run faster. -funroll-all-loops-funroll-all-loops implies the same options as -funroll-loops, -fsplit-ivs-in-unrollerA combination of -fweb and CSE is often sufficient to obtain the same effect. However, that is not reliable in cases where the loop body is more complicated than a single basic block. It also does not work at all on some architectures due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller-fpartial-inlining-finline-functions or -finline-small-functions options. Enabled at level -O2.
-fpredictive-commoningThis option is enabled at level -O3.
-fprefetch-loop-arraysThis option may generate better or worse code; results are highly dependent on the structure of loops within the source code.
Disabled at level -Os.
-fno-peephole-fno-peephole2-fno-peephole and -fno-peephole2 is in how they are implemented in the compiler; some targets use one, some use the other, a few use both. -fpeephole is enabled by default. -fpeephole2 enabled at levels -O2, -O3, -Os.
-fno-guess-branch-probabilityGCC uses heuristics to guess branch probabilities if they are not provided by profiling feedback (-fprofile-arcs). These heuristics are based on the control flow graph. If some branch probabilities are specified by ‘__builtin_expect’, then the heuristics are used to guess branch probabilities for the rest of the control flow graph, taking the ‘__builtin_expect’ info into account. The interactions between the heuristics and ‘__builtin_expect’ can be complex, and in some cases, it may be useful to disable the heuristics so that the effects of ‘__builtin_expect’ are easier to understand.
The default is -fguess-branch-probability at levels -O, -O2, -O3, -Os.
-freorder-blocksEnabled at levels -O2, -O3.
-freorder-blocks-and-partitionThis optimization is automatically turned off in the presence of exception handling, for linkonce sections, for functions with a user-defined section attribute and on any architecture that does not support named sections.
Enabled for x86 at levels -O2, -O3.
-freorder-functions.text.hot for most frequently executed functions and .text.unlikely for unlikely executed functions. Reordering is done by the linker so object file format must support named sections and linker must place them in a reasonable way. Also profile feedback must be available to make this option effective. See -fprofile-arcs for details.
Enabled at levels -O2, -O3, -Os.
-fstrict-aliasingunsigned int can alias an int, but not a void* or a double. A character type may alias any other type. Pay special attention to code like this:
union a_union {
int i;
double d;
};
int f() {
union a_union t;
t.d = 3.0;
return t.i;
} The practice of reading from a different union member than the one most recently written to (called “type-punning”) is common. Even with -fstrict-aliasing, type-punning is allowed, provided the memory is accessed through the union type. So, the code above works as expected. See Structures unions enumerations and bit-fields implementation. However, this code might not:
int f() {
union a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
} Similarly, access by taking the address, casting the resulting pointer and dereferencing the result has undefined behavior, even if the cast uses a union type, e.g.:
int f() {
double d = 3.0;
return ((union a_union *) &d)->i;
} The -fstrict-aliasing option is enabled at levels -O2, -O3, -Os.
-fstrict-overflowi + 10 > i is always true for signed i. This assumption is only valid if signed overflow is undefined, as the expression is false if i + 10 overflows when using twos complement arithmetic. When this option is in effect any attempt to determine whether an operation on signed numbers overflows must be written carefully to not actually involve overflow. This option also allows the compiler to assume strict pointer semantics: given a pointer to an object, if adding an offset to that pointer does not produce a pointer to the same object, the addition is undefined. This permits the compiler to conclude that p + u >
p is always true for a pointer p and unsigned integer u. This assumption is only valid because pointer wraparound is undefined, as the expression is false if p + u overflows using twos complement arithmetic.
See also the -fwrapv option. Using -fwrapv means that integer signed overflow is fully defined: it wraps. When -fwrapv is used, there is no difference between -fstrict-overflow and -fno-strict-overflow for integers. With -fwrapv certain types of overflow are permitted. For example, if the compiler gets an overflow when doing arithmetic on constants, the overflowed value can still be used with -fwrapv, but not otherwise.
The -fstrict-overflow option is enabled at levels -O2, -O3, -Os.
-falign-functions-falign-functions=n
-falign-functions=32 aligns functions to the next 32-byte boundary, but -falign-functions=24 aligns to the next 32-byte boundary only if this can be done by skipping 23 bytes or less. -fno-align-functions and -falign-functions=1 are equivalent and mean that functions are not aligned.
Some assemblers only support this flag when n is a power of two; in that case, it is rounded up.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-falign-labels-falign-labels=n
-falign-functions. This option can easily make code slower, because it must insert dummy operations for when the branch target is reached in the usual flow of the code. -fno-align-labels and -falign-labels=1 are equivalent and mean that labels are not aligned.
If -falign-loops or -falign-jumps are applicable and are greater than this value, then their values are used instead.
If n is not specified or is zero, use a machine-dependent default which is very likely to be ‘1’, meaning no alignment.
Enabled at levels -O2, -O3.
-falign-loops-falign-loops=n
-falign-functions. If the loops are executed many times, this makes up for any execution of the dummy operations. -fno-align-loops and -falign-loops=1 are equivalent and mean that loops are not aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-falign-jumps-falign-jumps=n
-falign-functions. In this case, no dummy operations need be executed. -fno-align-jumps and -falign-jumps=1 are equivalent and mean that loops are not aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-funit-at-a-time-funit-at-a-time has no effect, while -fno-unit-at-a-time implies -fno-toplevel-reorder and -fno-section-anchors. Enabled by default.
-fno-toplevel-reorderasm statements. Output them in the same order that they appear in the input file. When this option is used, unreferenced static variables are not removed. This option is intended to support existing code that relies on a particular ordering. For new code, it is better to use attributes when possible. Enabled at level -O0. When disabled explicitly, it also implies -fno-section-anchors, which is otherwise enabled at -O0 on some targets.
-fwebEnabled by default with -funroll-loops.
-fwhole-programmain and those merged by attribute externally_visible become static functions and in effect are optimized more aggressively by interprocedural optimizers. This option should not be used in combination with -flto. Instead relying on a linker plugin should provide safer and more precise information.
-flto[=n]
To use the link-time optimizer, -flto and optimization options should be specified at compile time and during the final link. For example:
gcc -c -O2 -flto foo.c gcc -c -O2 -flto bar.c gcc -o myprog -flto -O2 foo.o bar.o
The first two invocations to GCC save a bytecode representation of GIMPLE into special ELF sections inside foo.o and bar.o. The final invocation reads the GIMPLE bytecode from foo.o and bar.o, merges the two files into a single internal image, and compiles the result as usual. Since both foo.o and bar.o are merged into a single image, this causes all the interprocedural analyses and optimizations in GCC to work across the two files as if they were a single one. This means, for example, that the inliner is able to inline functions in bar.o into functions in foo.o and vice-versa.
Another (simpler) way to enable link-time optimization is:
gcc -o myprog -flto -O2 foo.c bar.c
The above generates bytecode for foo.c and bar.c, merges them together into a single GIMPLE representation and optimizes them as usual to produce myprog.
The only important thing to keep in mind is that to enable link-time optimizations you need to use the GCC driver to perform the link-step. GCC then automatically performs link-time optimization if any of the objects involved were compiled with the -flto. You generally should specify the optimization options to be used for link-time optimization though GCC will try to be clever at guessing an optimization level to use from the options used at compile-time if you fail to specify one at link-time. You can always override the automatic decision to do link-time optimization at link-time by passing -fno-lto to the link command.
To make whole program optimization effective, it is necessary to make certain whole program assumptions. The compiler needs to know what functions and variables can be accessed by libraries and runtime outside of the link-time optimized unit. When supported by the linker, the linker plugin (see -fuse-linker-plugin) passes information to the compiler about used and externally visible symbols. When the linker plugin is not available, -fwhole-program should be used to allow the compiler to make these assumptions, which leads to more aggressive optimization decisions.
When -fuse-linker-plugin is not enabled then, when a file is compiled with -flto, the generated object file is larger than a regular object file because it contains GIMPLE bytecodes and the usual final code (see -ffat-lto-objects. This means that object files with LTO information can be linked as normal object files; if -fno-lto is passed to the linker, no interprocedural optimizations are applied. Note that when -fno-fat-lto-objects is enabled the compile-stage is faster but you cannot perform a regular, non-LTO link on them.
Additionally, the optimization flags used to compile individual files are not necessarily related to those used at link time. For instance,
gcc -c -O0 -ffat-lto-objects -flto foo.c gcc -c -O0 -ffat-lto-objects -flto bar.c gcc -o myprog -O3 foo.o bar.o
This produces individual object files with unoptimized assembler code, but the resulting binary myprog is optimized at -O3. If, instead, the final binary is generated with -fno-lto, then myprog is not optimized.
When producing the final binary, GCC only applies link-time optimizations to those files that contain bytecode. Therefore, you can mix and match object files and libraries with GIMPLE bytecodes and final object code. GCC automatically selects which files to optimize in LTO mode and which files to link without further processing.
There are some code generation flags preserved by GCC when generating bytecodes, as they need to be used during the final link stage. Generally options specified at link-time override those specified at compile-time.
If you do not specify an optimization level option -O at link-time then GCC will compute one based on the optimization levels used when compiling the object files. The highest optimization level will win here.
Currently, the following options and their setting are take from the first object file that explicitely specified it: -fPIC, -fpic, -fpie, -fcommon, -fexceptions, -fnon-call-exceptions, -fgnu-tm and all the -m target flags.
Certain ABI changing flags are required to match in all compilation-units and trying to override this at link-time with a conflicting value is ignored. This includes options such as -freg-struct-return and -fpcc-struct-return.
Other options such as -ffp-contract, -fno-strict-overflow, -fwrapv, -fno-trapv or -fno-strict-aliasing are passed through to the link stage and merged conservatively for conflicting translation units. Specifically -fno-strict-overflow, -fwrapv and -fno-trapv take precedence and for example -ffp-contract=off takes precedence over -ffp-contract=fast. You can override them at linke-time.
It is recommended that you compile all the files participating in the same link with the same options and also specify those options at link time.
If LTO encounters objects with C linkage declared with incompatible types in separate translation units to be linked together (undefined behavior according to ISO C99 6.2.7), a non-fatal diagnostic may be issued. The behavior is still undefined at run time. Similar diagnostics may be raised for other languages.
Another feature of LTO is that it is possible to apply interprocedural optimizations on files written in different languages:
gcc -c -flto foo.c g++ -c -flto bar.cc gfortran -c -flto baz.f90 g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran
Notice that the final link is done with g++ to get the C++ runtime libraries and -lgfortran is added to get the Fortran runtime libraries. In general, when mixing languages in LTO mode, you should use the same link command options as when mixing languages in a regular (non-LTO) compilation.
If object files containing GIMPLE bytecode are stored in a library archive, say libfoo.a, it is possible to extract and use them in an LTO link if you are using a linker with plugin support. To create static libraries suitable for LTO, use gcc-ar and gcc-ranlib instead of ar and ranlib; to show the symbols of object files with GIMPLE bytecode, use gcc-nm. Those commands require that ar, ranlib and nm have been compiled with plugin support. At link time, use the the flag -fuse-linker-plugin to ensure that the library participates in the LTO optimization process:
gcc -o myprog -O2 -flto -fuse-linker-plugin a.o b.o -lfoo
With the linker plugin enabled, the linker extracts the needed GIMPLE files from libfoo.a and passes them on to the running GCC to make them part of the aggregated GIMPLE image to be optimized.
If you are not using a linker with plugin support and/or do not enable the linker plugin, then the objects inside libfoo.a are extracted and linked as usual, but they do not participate in the LTO optimization process. In order to make a static library suitable for both LTO optimization and usual linkage, compile its object files with -flto -ffat-lto-objects.
Link-time optimizations do not require the presence of the whole program to operate. If the program does not require any symbols to be exported, it is possible to combine -flto and -fwhole-program to allow the interprocedural optimizers to use more aggressive assumptions which may lead to improved optimization opportunities. Use of -fwhole-program is not needed when linker plugin is active (see -fuse-linker-plugin).
The current implementation of LTO makes no attempt to generate bytecode that is portable between different types of hosts. The bytecode files are versioned and there is a strict version check, so bytecode files generated in one version of GCC will not work with an older or newer version of GCC.
Link-time optimization does not work well with generation of debugging information. Combining -flto with -g is currently experimental and expected to produce unexpected results.
If you specify the optional n, the optimization and code generation done at link time is executed in parallel using n parallel jobs by utilizing an installed make program. The environment variable MAKE may be used to override the program used. The default value for n is 1.
You can also specify -flto=jobserver to use GNU make's job server mode to determine the number of parallel jobs. This is useful when the Makefile calling GCC is already executing in parallel. You must prepend a ‘+’ to the command recipe in the parent Makefile for this to work. This option likely only works if MAKE is GNU make.
-flto-partition=alg
1to1 to specify a partitioning mirroring the original source files or balanced to specify partitioning into equally sized chunks (whenever possible) or max to create new partition for every symbol where possible. Specifying none as an algorithm disables partitioning and streaming completely. The default value is balanced. While 1to1 can be used as an workaround for various code ordering issues, the max partitioning is intended for internal testing only. -flto-compression-level=n
-flto). Valid values are 0 (no compression) to 9 (maximum compression). Values outside this range are clamped to either 0 or 9. If the option is not given, a default balanced compression setting is used. -flto-report-flto). Disabled by default.
-flto-report-wpa-flto-report, but only print for the WPA phase of Link Time Optimization. -fuse-linker-pluginThis option enables the extraction of object files with GIMPLE bytecode out of library archives. This improves the quality of optimization by exposing more code to the link-time optimizer. This information specifies what symbols can be accessed externally (by non-LTO object or during dynamic linking). Resulting code quality improvements on binaries (and shared libraries that use hidden visibility) are similar to -fwhole-program. See -flto for a description of the effect of this flag and how to use it.
This option is enabled by default when LTO support in GCC is enabled and GCC was configured for use with a linker supporting plugins (GNU ld 2.21 or newer or gold).
-ffat-lto-objects-flto and is ignored at link time. -fno-fat-lto-objects improves compilation time over plain LTO, but requires the complete toolchain to be aware of LTO. It requires a linker with linker plugin support for basic functionality. Additionally, nm, ar and ranlib need to support linker plugins to allow a full-featured build environment (capable of building static libraries etc). GCC provides the gcc-ar, gcc-nm, gcc-ranlib wrappers to pass the right options to these tools. With non fat LTO makefiles need to be modified to use them.
The default is -fno-fat-lto-objects on targets with linker plugin support.
-fcompare-elimThis pass only applies to certain targets that cannot explicitly represent the comparison operation before register allocation is complete.
Enabled at levels -O, -O2, -O3, -Os.
-fuse-ld=bfdbfd linker instead of the default linker. -fuse-ld=goldgold linker instead of the default linker. -fcprop-registersEnabled at levels -O, -O2, -O3, -Os.
-fprofile-correction-fprofile-dir=path
-fprofile-generate, -ftest-coverage, -fprofile-arcs and used by -fprofile-use and -fbranch-probabilities and its related options. Both absolute and relative paths can be used. By default, GCC uses the current directory as path, thus the profile data file appears in the same directory as the object file. -fprofile-generate-fprofile-generate=path
-fprofile-generate both when compiling and when linking your program. The following options are enabled: -fprofile-arcs, -fprofile-values, -fvpt.
If path is specified, GCC looks at the path to find the profile feedback data files. See -fprofile-dir.
-fprofile-use-fprofile-use=path
The following options are enabled: -fbranch-probabilities, -fvpt, -funroll-loops, -fpeel-loops, -ftracer, -ftree-vectorize, ftree-loop-distribute-patterns
By default, GCC emits an error message if the feedback profiles do not match the source code. This error can be turned into a warning by using -Wcoverage-mismatch. Note this may result in poorly optimized code.
If path is specified, GCC looks at the path to find the profile feedback data files. See -fprofile-dir.
The following options control compiler behavior regarding floating-point arithmetic. These options trade off between speed and correctness. All must be specifically enabled.
-ffloat-storeThis option prevents undesirable excess precision on machines such as the 68000 where the floating registers (of the 68881) keep more precision than a double is supposed to have. Similarly for the x86 architecture. For most programs, the excess precision does only good, but a few programs rely on the precise definition of IEEE floating point. Use -ffloat-store for such programs, after modifying them to store all pertinent intermediate computations into variables.
-fexcess-precision=style
float and double types and the processor does not support operations rounding to those types. By default, -fexcess-precision=fast is in effect; this means that operations are carried out in the precision of the registers and that it is unpredictable when rounding to the types specified in the source code takes place. When compiling C, if -fexcess-precision=standard is specified then excess precision follows the rules specified in ISO C99; in particular, both casts and assignments cause values to be rounded to their semantic types (whereas -ffloat-store only affects assignments). This option is enabled by default for C if a strict conformance option such as -std=c99 is used. -fexcess-precision=standard is not implemented for languages other than C, and has no effect if -funsafe-math-optimizations or -ffast-math is specified. On the x86, it also has no effect if -mfpmath=sse or -mfpmath=sse+387 is specified; in the former case, IEEE semantics apply without excess precision, and in the latter, rounding is unpredictable.
-ffast-math-fno-math-errno, -funsafe-math-optimizations, -ffinite-math-only, -fno-rounding-math, -fno-signaling-nans and -fcx-limited-range. This option causes the preprocessor macro __FAST_MATH__ to be defined.
This option is not turned on by any -O option besides -Ofast since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specifications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
-fno-math-errnoerrno 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. This option is not turned on by any -O option since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specifications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
The default is -fmath-errno.
On Darwin systems, the math library never sets errno. There is therefore no reason for the compiler to consider the possibility that it might, and -fno-math-errno is the default.
-funsafe-math-optimizationsThis option is not turned on by any -O option since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specifications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specifications. Enables -fno-signed-zeros, -fno-trapping-math, -fassociative-math and -freciprocal-math.
The default is -fno-unsafe-math-optimizations.
-fassociative-math(x + 2**52) - 2**52. May also reorder floating-point comparisons and thus may not be used when ordered comparisons are required. This option requires that both -fno-signed-zeros and -fno-trapping-math be in effect. Moreover, it doesn't make much sense with -frounding-math. For Fortran the option is automatically enabled when both -fno-signed-zeros and -fno-trapping-math are in effect. The default is -fno-associative-math.
-freciprocal-mathx / y can be replaced with x * (1/y), which is useful if (1/y) is subject to common subexpression elimination. Note that this loses precision and increases the number of flops operating on the value. The default is -fno-reciprocal-math.
-ffinite-math-onlyThis option is not turned on by any -O option since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specifications for math functions. It may, however, yield faster code for programs that do not require the guarantees of these specifications.
The default is -fno-finite-math-only.
-fno-signed-zeros-ffinite-math-only). This option implies that the sign of a zero result isn't significant. The default is -fsigned-zeros.
-fno-trapping-math-fno-signaling-nans be in effect. Setting this option may allow faster code if one relies on “non-stop” IEEE arithmetic, for example. This option should never be turned on by any -O option since it can result in incorrect output for programs that depend on an exact implementation of IEEE or ISO rules/specifications for math functions.
The default is -ftrapping-math.
-frounding-mathThe default is -fno-rounding-math.
This option is experimental and does not currently guarantee to disable all GCC optimizations that are affected by rounding mode. Future versions of GCC may provide finer control of this setting using C99's FENV_ACCESS pragma. This command-line option will be used to specify the default state for FENV_ACCESS.
-fsignaling-nans-ftrapping-math. This option causes the preprocessor macro __SUPPORT_SNAN__ to be defined.
The default is -fno-signaling-nans.
This option is experimental and does not currently guarantee to disable all GCC optimizations that affect signaling NaN behavior.
-fsingle-precision-constant-fcx-limited-rangeNaN
+ I*NaN, with an attempt to rescue the situation in that case. The default is -fno-cx-limited-range, but is enabled by -ffast-math. This option controls the default setting of the ISO C99 CX_LIMITED_RANGE pragma. Nevertheless, the option applies to all languages.
-fcx-fortran-rulesNaN
+ I*NaN, with an attempt to rescue the situation in that case. The default is -fno-cx-fortran-rules.
The following options control optimizations that may improve performance, but are not enabled by any -O options. This section includes experimental options that may produce broken code.
-fbranch-probabilities-fprofile-arcs (see Options for Debugging Your Program or gcc), you can compile it a second time using -fbranch-probabilities, to improve optimizations based on the number of times each branch was taken. When a program compiled with -fprofile-arcs exits, it saves arc execution counts to a file called sourcename.gcda for each source file. The information in this data file is very dependent on the structure of the generated code, so you must use the same source code and the same optimization options for both compilations. With -fbranch-probabilities, GCC puts a ‘REG_BR_PROB’ note on each ‘JUMP_INSN’ and ‘CALL_INSN’. These can be used to improve optimization. Currently, they are only used in one place: in reorg.c, instead of guessing which path a branch is most likely to take, the ‘REG_BR_PROB’ values are used to exactly determine which path is taken more often.
-fprofile-values-fprofile-arcs, it adds code so that some data about values of expressions in the program is gathered. With -fbranch-probabilities, it reads back the data gathered from profiling values of expressions for usage in optimizations.
Enabled with -fprofile-generate and -fprofile-use.
-fprofile-reorder-functionsEnabled with -fprofile-use.
-fvpt-fprofile-arcs, this option instructs the compiler to add code to gather information about values of expressions. With -fbranch-probabilities, it reads back the data gathered and actually performs the optimizations based on them. Currently the optimizations include specialization of division operations using the knowledge about the value of the denominator.
-frename-registersEnabled by default with -funroll-loops and -fpeel-loops.
-ftracerEnabled with -fprofile-use.
-funroll-loops-funroll-loops implies -frerun-cse-after-loop, -fweb and -frename-registers. It also turns on complete loop peeling (i.e. complete removal of loops with a small constant number of iterations). This option makes code larger, and may or may not make it run faster. Enabled with -fprofile-use.
-funroll-all-loops-funroll-all-loops implies the same options as -funroll-loops. -fpeel-loopsEnabled with -fprofile-use.
-fmove-loop-invariants-O1 -funswitch-loops-ffunction-sections-fdata-sectionsUse these options on systems where the linker can perform optimizations to improve locality of reference in the instruction space. Most systems using the ELF object format and SPARC processors running Solaris 2 have linkers with such optimizations. AIX may have these optimizations in the future.
Only use these options when there are significant benefits from doing so. When you specify these options, the assembler and linker create larger object and executable files and are also slower. You cannot use gprof on all systems if you specify this option, and you may have problems with debugging if you specify both this option and -g.
-fbranch-target-load-optimize-fbranch-target-load-optimize2-fbtr-bb-exclusive-fstack-protectoralloca, and functions with buffers larger than 8 bytes. The guards are initialized when a function is entered and then checked when the function exits. If a guard check fails, an error message is printed and the program exits. -fstack-protector-all-fstack-protector except that all functions are protected. -fstack-protector-strong-fstack-protector but includes additional functions to be protected — those that have local array definitions, or have references to local frame addresses. -fsection-anchorsFor example, the implementation of the following function foo:
static int a, b, c;
int foo (void) { return a + b + c; } usually calculates the addresses of all three variables, but if you compile it with -fsection-anchors, it accesses the variables from a common anchor point instead. The effect is similar to the following pseudocode (which isn't valid C):
int foo (void)
{
register int *xr = &x;
return xr[&a - &x] + xr[&b - &x] + xr[&c - &x];
} Not all targets support this option.
--param name=value
--param option. The names of specific parameters, and the meaning of the values, are tied to the internals of the compiler, and are subject to change without notice in future releases.
In each case, the value is an integer. The allowable choices for name are:
predictable-branch-outcomemax-crossjump-edges-fcrossjumping is O(N^2) in the number of edges incoming to each block. Increasing values mean more aggressive optimization, making the compilation time increase with probably small improvement in executable size. min-crossjump-insnsmax-grow-copy-bb-insnsmax-goto-duplication-insnsmax-delay-slot-insn-searchmax-delay-slot-live-searchmax-gcse-memorymax-gcse-insertion-ratiomax-pending-list-lengthmax-modulo-backtrack-attemptsmax-inline-insns-singlemax-inline-insns-auto-finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied. The default value is 40. inline-min-speedup--param max-inline-insns-single and --param max-inline-insns-auto. large-function-insns--param large-function-growth. This parameter is useful primarily to avoid extreme compilation time caused by non-linear algorithms used by the back end. The default value is 2700. large-function-growthlarge-unit-insns--param inline-unit-growth. For small units this might be too tight. For example, consider a unit consisting of function A that is inline and B that just calls A three times. If B is small relative to A, the growth of unit is 300\% and yet such inlining is very sane. For very large units consisting of small inlineable functions, however, the overall unit growth limit is needed to avoid exponential explosion of code size. Thus for smaller units, the size is increased to --param large-unit-insns before applying --param inline-unit-growth. The default is 10000. inline-unit-growthipcp-unit-growthlarge-stack-framelarge-stack-frame-growthmax-inline-insns-recursivemax-inline-insns-recursive-autoFor functions declared inline, --param max-inline-insns-recursive is taken into account. For functions not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-insns-recursive-auto is used. The default value is 450.
max-inline-recursive-depthmax-inline-recursive-depth-autoFor functions declared inline, --param max-inline-recursive-depth is taken into account. For functions not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-recursive-depth-auto is used. The default value is 8.
min-inline-recursive-probabilityWhen profile feedback is available (see -fprofile-generate) the actual recursion depth can be guessed from probability that function recurses via a given call expression. This parameter limits inlining only to call expressions whose probability exceeds the given threshold (in percents). The default value is 10.
early-inlining-insnsmax-early-inliner-iterationsmax-early-inliner-iterationscomdat-sharing-probabilitycomdat-sharing-probabilitymin-vect-loop-bound-ftree-vectorize is used. The number of iterations after vectorization needs to be greater than the value specified by this option to allow vectorization. The default value is 0. gcse-cost-distance-ratiogcse-unrestricted-cost. Specifying 0 disables hoisting of simple expressions. The default value is 10. gcse-unrestricted-costmax-hoist-depthmax-tail-merge-comparisonsmax-tail-merge-iterationsmax-unrolled-insnsmax-average-unrolled-insnsmax-unroll-timesmax-peeled-insnsmax-peel-timesmax-peel-branchesmax-completely-peeled-insnsmax-completely-peel-timesmax-completely-peel-loop-nest-depthmax-unswitch-insnsmax-unswitch-levellim-expensiveiv-consider-all-candidates-boundiv-max-considered-usesiv-always-prune-cand-set-boundscev-max-expr-sizescev-max-expr-complexityomega-max-varsomega-max-geqsomega-max-eqsomega-max-wild-cardsomega-hash-table-sizeomega-max-keysomega-eliminate-redundant-constraintsvect-max-version-for-alignment-checksvect-max-version-for-alias-checksvect-max-peeling-for-alignmentmax-iterations-to-trackhot-bb-count-ws-permillehot-bb-frequency-fractionmax-predicted-iterationsbuiltin-expect-probabilityalign-thresholdalign-loop-iterationstracer-dynamic-coveragetracer-dynamic-coverage-feedbackThe tracer-dynamic-coverage-feedback is used only when profile feedback is available. The real profiles (as opposed to statically estimated ones) are much less balanced allowing the threshold to be larger value.
tracer-max-code-growthtracer-min-branch-ratiotracer-min-branch-ratiotracer-min-branch-ratio-feedbackSimilarly to tracer-dynamic-coverage two values are present, one for compilation for profile feedback and one for compilation without. The value for compilation with profile feedback needs to be more conservative (higher) in order to make tracer effective.
max-cse-path-lengthmax-cse-insnsggc-min-expandThe default is 30% + 70% * (RAM/1GB) with an upper bound of 100% when RAM >= 1GB. If getrlimit is available, the notion of “RAM” is the smallest of actual RAM and RLIMIT_DATA or RLIMIT_AS. If GCC is not able to calculate RAM on a particular platform, the lower bound of 30% is used. Setting this parameter and ggc-min-heapsize to zero causes a full collection to occur at every opportunity. This is extremely slow, but can be useful for debugging.
ggc-min-heapsizeggc-min-expand% beyond ggc-min-heapsize. Again, tuning this may improve compilation speed, and has no effect on code generation. The default is the smaller of RAM/8, RLIMIT_RSS, or a limit that tries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, but with a lower bound of 4096 (four megabytes) and an upper bound of 131072 (128 megabytes). If GCC is not able to calculate RAM on a particular platform, the lower bound is used. Setting this parameter very large effectively disables garbage collection. Setting this parameter and ggc-min-expand to zero causes a full collection to occur at every opportunity.
max-reload-search-insnsmax-cselib-memory-locationsreorder-blocks-duplicatereorder-blocks-duplicate-feedbackThe reorder-block-duplicate-feedback is used only when profile feedback is available. It may be set to higher values than reorder-block-duplicate since information about the hot spots is more accurate.
max-sched-ready-insnsmax-sched-region-blocksmax-pipeline-region-blocksmax-sched-region-insnsmax-pipeline-region-insnsmin-spec-probmax-sched-extend-regions-itersmax-sched-insn-conflict-delaysched-spec-prob-cutoffsched-spec-state-edge-prob-cutoffsched-mem-true-dep-costselsched-max-lookaheadselsched-max-sched-timesselsched-max-insns-to-renamesms-min-scmax-last-value-rtlinteger-share-limitssp-buffer-size-fstack-protection is used. min-size-for-stack-sharingmax-jump-thread-duplication-stmtsmax-fields-for-field-sensitive-O0 and -O1, and 100 for -Os, -O2, and -O3. prefetch-latencysimultaneous-prefetches). simultaneous-prefetchesl1-cache-line-sizel1-cache-sizel2-cache-sizemin-insn-to-prefetch-ratioprefetch-min-insn-to-mem-ratiouse-canonical-typesswitch-conversion-max-branch-ratioswitch-conversion-max-branch-ratio times the number of branches in the switch. max-partial-antic-length-ftree-pre) when optimizing at -O3 and above. For some sorts of source code the enhanced partial redundancy elimination optimization can run away, consuming all of the memory available on the host machine. This parameter sets a limit on the length of the sets that are computed, which prevents the runaway behavior. Setting a value of 0 for this parameter allows an unlimited set length. sccvn-max-scc-sizesccvn-max-alias-queries-per-accessira-max-loops-numira-max-conflict-table-sizeira-loop-reserved-regs-O3). The number of available registers reserved for some other purposes is given by this parameter. The default value of the parameter is 2, which is the minimal number of registers needed by typical instructions. This value is the best found from numerous experiments. loop-invariant-max-bbs-in-loop-O1 and 10000 for -O2 and above. loop-max-datarefs-for-datadepsmax-vartrack-sizemax-vartrack-expr-depthmin-nondebug-insn-uid-fvar-tracking-assignments, but debug insns may get (non-overlapping) uids above it if the reserved range is exhausted. ipa-sra-ptr-growth-factoripa-sra-ptr-growth-factor times the size of the original pointer parameter. tm-max-aggregate-size-fgnu-tm. graphite-max-nb-scop-paramsgraphite-max-bbs-per-functionloop-block-tile-size-floop-block or -floop-strip-mine, strip mine each loop in the loop nest by a given number of iterations. The strip length can be changed using the loop-block-tile-size parameter. The default value is 51 iterations. ipa-cp-value-list-sizeipa-cp-value-list-size is the maximum number of values and types it stores per one formal parameter of a function. ipa-cp-eval-thresholdipa-cp-eval-threshold. ipa-max-agg-itemsipa-max-agg-items controls the maximum number of such values per one parameter. ipa-cp-loop-hint-bonusipa-cp-loop-hint-bonus bonus to the profitability score of the candidate. ipa-cp-array-index-hint-bonusipa-cp-array-index-hint-bonus bonus to the profitability score of the candidate. lto-partitionslto-minpartitioncxx-max-namespaces-for-diagnostic-helpsink-frequency-thresholdmax-stores-to-sink-ftree-vectorize) or if-conversion (-ftree-loop-if-convert) is disabled. The default is 2. allow-load-data-races-fmemory-model= option. allow-store-data-races-fmemory-model= option. allow-packed-load-data-races-fmemory-model= option. allow-packed-store-data-races-fmemory-model= option. case-values-thresholdtree-reassoc-widthsched-pressure-algorithm-fsched-pressure. Algorithm 1 is the original implementation and is the more likely to prevent instructions from being reordered. Algorithm 2 was designed to be a compromise between the relatively conservative approach taken by algorithm 1 and the rather aggressive approach taken by the default scheduler. It relies more heavily on having a regular register file and accurate register pressure classes. See haifa-sched.c in the GCC sources for more details. The default choice depends on the target.
max-slsr-cand-scanasan-globals-fsanitize=address option. To disable global objects protection use --param asan-globals=0. asan-stack-fsanitize=address. To disable stack protection use --param asan-stack=0 option. asan-instrument-reads-fsanitize=address. To disable memory reads protection use --param asan-instrument-reads=0. asan-instrument-writes-fsanitize=address. To disable memory writes protection use --param asan-instrument-writes=0 option. asan-memintrin-fsanitize=address. To disable built-in functions protection use --param asan-memintrin=0. asan-use-after-return-fsanitize=address option. To disable use-after-return detection use --param asan-use-after-return=0. asan-instrumentation-with-call-threshold--param asan-instrumentation-with-call-threshold=0.
© Free Software Foundation
Licensed under the GNU Free Documentation License, Version 1.3.
https://gcc.gnu.org/onlinedocs/gcc-4.9.3/gcc/Optimize-Options.html