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 would 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-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-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
-fexpensive-optimizations
-fgcse -fgcse-lm
-finline-small-functions
-findirect-inlining
-fipa-sra
-foptimize-sibling-calls
-fpartial-inlining
-fpeephole2
-fregmove
-freorder-blocks -freorder-functions
-frerun-cse-after-loop
-fsched-interblock -fsched-spec
-fschedule-insns -fschedule-insns2
-fstrict-aliasing -fstrict-overflow
-ftree-switch-conversion
-ftree-pre
-ftree-vrp
Please note the warning under -fgcse about
invoking -O2 on programs that use computed gotos.
-O3-O0-Os-Os disables the following optimization flags:
-falign-functions -falign-jumps -falign-loops
-falign-labels -freorder-blocks -freorder-blocks-and-partition
-fprefetch-loop-arrays -ftree-vect-loop-version
-OfastIf 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 would be -fno-foo. In the table below, only one of the forms is listed—the one you typically will 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-default-inline-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=styleThe 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 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-inlineinline keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
Note that if you are not optimizing, no functions can be expanded inline.
-finline-small-functionsEnabled at level -O2.
-findirect-inliningEnabled 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=nInlining 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-dllexportdllexport
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 the variable was 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 will result in non-conforming
behavior.
-fmodulo-sched-fmodulo-sched-allow-regmoves-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.
-fmudflap -fmudflapth -fmudflapirenv MUDFLAP_OPTIONS=-help a.out
for its options.
Use -fmudflapth instead of -fmudflap to compile and to
link if your program is multi-threaded. Use -fmudflapir, in
addition to -fmudflap or -fmudflapth, if
instrumentation should ignore pointer reads. This produces less
instrumentation (and therefore faster execution) and still provides
some protection against outright memory corrupting writes, but allows
erroneously read data to propagate within a program.
-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 will follow the jump when the condition
tested is false.
Enabled at levels -O2, -O3, -Os.
-fcse-skip-blocksif 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 runtime 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-lmEnabled by default when gcse is enabled.
-fgcse-smNot enabled at any optimization level.
-fgcse-lasNot enabled at any optimization level.
-fgcse-after-reload-funsafe-loop-optimizations-fcrossjumpingEnabled at levels -O2, -O3, -Os.
-fauto-inc-dec-fdce-fdse-fif-conversionif-conversion2.
Enabled at levels -O, -O2, -O3, -Os.
-fif-conversion2Enabled at levels -O, -O2, -O3, -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 which 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.
-fexpensive-optimizationsEnabled at levels -O2, -O3, -Os.
-foptimize-register-move-fregmoveNote -fregmove and -foptimize-register-move are the same optimization.
Enabled at levels -O2, -O3, -Os.
-fira-algorithm=algorithmpriority or
CB. The first algorithm specifies Chow's priority coloring,
the second one specifies Chaitin-Briggs coloring. The second
algorithm can be unimplemented for some architectures. If it is
implemented, it is the default because Chaitin-Briggs coloring as a
rule generates a better code.
-fira-region=regionall, mixed, or
one. The first value means using all loops as register
allocation regions, the second value which is the default means using
all loops except for loops with small register pressure as the
regions, and third one means using all function as a single region.
The first value can give best result for machines with small size and
irregular register set, the third one results in faster and generates
decent code and the smallest size code, and the default value usually
give the best results in most cases and for most architectures.
-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-insns2Enabled at levels -O2, -O3, -Os.
-fno-sched-interblock-fno-sched-spec-fsched-pressure-fsched-spec-load-fsched-spec-load-dangerous-fsched-stalled-insns-fsched-stalled-insns=n-fsched-stalled-insns-dep-fsched-stalled-insns-dep=n-fsched2-use-superblocksThis only makes sense when scheduling after register allocation, i.e. with
-fschedule-insns2 or at -O2 or higher.
-fsched-group-heuristic-fsched-critical-path-heuristic-fsched-spec-insn-heuristic-fsched-rank-heuristic-fsched-last-insn-heuristic-fsched-dep-count-heuristic-freschedule-modulo-scheduled-loops-fselective-scheduling-fselective-scheduling2-fsel-sched-pipelining-fsel-sched-pipelining-outer-loops-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-stack-ftree-reassoc-ftree-pre-ftree-forwprop-ftree-fre-ftree-phiprop-ftree-copy-prop-fipa-pure-const-fipa-reference-fipa-struct-reorgWith this flag, the program debug info reflects a new structure layout.
-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-fipa-cp-clone-fipa-matrix-reorg-ftree-sink-ftree-bit-ccp-ftree-ccp-ftree-switch-conversion-ftree-dce-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-ftree-dse-ftree-ch-ftree-loop-optimize-ftree-loop-linear-floop-interchange DO J = 1, M
DO I = 1, N
A(J, I) = A(J, I) * C
ENDDO
ENDDO
loop interchange will transform the loop as if the user had 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-mine DO I = 1, N
A(I) = A(I) + C
ENDDO
loop strip mining will transform the loop as if the user had 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-block DO I = 1, N
DO J = 1, M
A(J, I) = B(I) + C(J)
ENDDO
ENDDO
loop blocking will transform the loop as if the user had 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 will iterate over a smaller amount of data
that 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-floop-flatten-floop-parallelize-all-fcheck-data-deps-ftree-loop-if-convert-ftree-loop-if-convert-stores for (i = 0; i < N; i++)
if (cond)
A[i] = expr;
would be transformed to
for (i = 0; i < N; i++)
A[i] = cond ? expr : A[i];
potentially producing data races.
-ftree-loop-distribution DO 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-patternsThis 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-ftree-loop-ivcanon-fivopts-ftree-parallelize-loops=n-ftree-pta-ftree-sra-ftree-copyrename-ftree-ter-ftree-vectorize-ftree-slp-vectorize-ftree-vect-loop-version-fvect-cost-model-ftree-vrp-ftracer-funroll-loops-funroll-all-loops-fsplit-ivs-in-unrollerCombination of -fweb and CSE is often sufficient to obtain the same effect. However in cases the loop body is more complicated than a single basic block, this is not reliable. It also does not work at all on some of the architectures due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller-fpartial-inliningEnabled 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-fpeephole is enabled by default.
-fpeephole2 enabled at levels -O2, -O3, -Os.
-fno-guess-branch-probabilityGCC will use 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 will be 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.
-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 in 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 will work 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 will always be 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 will
overflow 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-fno-align-functions and -falign-functions=1 are equivalent and mean that functions will not be 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-fno-align-labels and -falign-labels=1 are equivalent and mean that labels will not be 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-fno-align-loops and -falign-loops=1 are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-falign-jumps-falign-jumps=n-fno-align-jumps and -falign-jumps=1 are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-funit-at-a-timeEnabled 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
will not be removed. This option is intended to support existing code
which relies on a particular ordering. For new code, it is better to
use attributes.
Enabled at level -O0. When disabled explicitly, it also imply
-fno-section-anchors that 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. If gold is used as the linker plugin, externally_visible attributes are automatically added to functions (not variable yet due to a current gold issue) that are accessed outside of LTO objects according to resolution file produced by gold. For other linkers that cannot generate resolution file, explicit externally_visible attributes are still necessary.
While this option is equivalent to proper use of the static keyword for
programs consisting of a single file, in combination with option
-flto this flag can be used to
compile many smaller scale programs since the functions and variables become
local for the whole combined compilation unit, not for the single source file
itself.
This option implies -fwhole-file for Fortran programs.
-flto[=n]To use the link-time optimizer, -flto needs to 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 the -flto flag needs to be passed to both the compile and the link commands.
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.
Note that 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. This means that object files with LTO information can be linked as normal object files; if -flto is not passed to the linker, no interprocedural optimizations are applied.
Additionally, the optimization flags used to compile individual files are not necessarily related to those used at link time. For instance,
gcc -c -O0 -flto foo.c
gcc -c -O0 -flto bar.c
gcc -o myprog -flto -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 without -flto, then myprog is not optimized.
When producing the final binary with -flto, 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 that GCC preserves when generating bytecodes, as they need to be used during the final link stage. Currently, the following options are saved into the GIMPLE bytecode files: -fPIC, -fcommon and all the -m target flags.
At link time, these options are read in and reapplied. Note that the current implementation makes no attempt to recognize conflicting values for these options. If different files have conflicting option values (e.g., one file is compiled with -fPIC and another isn't), the compiler simply uses the last value read from the bytecode files. It is recommended, then, that you compile all the files participating in the same link with the same options.
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 runtime.
Another feature of LTO is that it is possible to apply interprocedural optimizations on files written in different languages. This requires support in the language front end. Currently, the C, C++ and Fortran front ends are capable of emitting GIMPLE bytecodes, so something like this should work:
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; all you need to add is -flto to all the compile and link commands.
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 enable this feature, use the flag -fuse-linker-plugin at link time:
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.
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/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 wrong 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.
This option is disabled by default.
-flto-partition=alg1to1 to specify a partitioning mirroring
the original source files or balanced to specify partitioning
into equally sized chunks (whenever possible). Specifying none
as an algorithm disables partitioning and streaming completely. The
default value is balanced.
-flto-compression-level=n-flto-reportDisabled by default.
-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).
-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.
-fcprop-registersEnabled at levels -O, -O2, -O3, -Os.
-fprofile-correction-fprofile-dir=path-fprofile-generate-fprofile-generate=pathThe following options are enabled: -fprofile-arcs, -fprofile-values, -fvpt.
If path is specified, GCC will look at the path to find
the profile feedback data files. See -fprofile-dir.
-fprofile-use-fprofile-use=pathThe following options are enabled: -fbranch-probabilities, -fvpt,
-funroll-loops, -fpeel-loops, -ftracer
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 will look 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=stylefloat 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 will follow 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-mathThis 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
which 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-errnoThis option is not turned on by any -O option since it can result in incorrect output for programs which 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 which 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 which 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-zerosThe default is -fsigned-zeros.
-fno-trapping-mathThis option should never be turned on by any -O option since it can result in incorrect output for programs which 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-nansThis 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-probabilitiesWith -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-valuesWith -fbranch-probabilities, it reads back the data gathered from profiling values of expressions for usage in optimizations.
Enabled with -fprofile-generate and -fprofile-use.
-fvptWith -fbranch-probabilities, it reads back the data gathered
and actually performs the optimizations based on them.
Currently the optimizations include specialization of division operation
using the knowledge about the value of the denominator.
-frename-registersEnabled by default with -funroll-loops and -fpeel-loops.
-ftracerEnabled with -fprofile-use.
-funroll-loopsEnabled with -fprofile-use.
-funroll-all-loops-fpeel-loopsEnabled with -fprofile-use.
-fmove-loop-invariants-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 will
create larger object and executable files and will also be slower.
You will not be able to 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-protector-fstack-protector-all-fsection-anchorsFor example, the implementation of the following function foo:
static int a, b, c;
int foo (void) { return a + b + c; }
would usually calculate the addresses of all three variables, but if you compile it with -fsection-anchors, it will access 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=valueThe 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 given in the following table:
struct-reorg-cold-struct-ratiopredictable-branch-outcomemax-crossjump-edgesmin-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-inline-insns-singlemax-inline-insns-autolarge-function-insnslarge-function-growthlarge-unit-insnsinline-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 function 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 function 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 will recurse via
given call expression. This parameter limits inlining only to call expression
whose probability exceeds given threshold (in percents). The default value is
10.
early-inlining-insnsmax-early-inliner-iterationsmax-early-inliner-iterationscomdat-sharing-probabilitycomdat-sharing-probabilitymin-vect-loop-boundgcse-cost-distance-ratiogcse-unrestricted-costmax-hoist-depthmax-unrolled-insnsmax-average-unrolled-insnsmax-unroll-timesmax-peeled-insnsmax-peel-timesmax-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-checksmax-iterations-to-trackhot-bb-count-fractionhot-bb-frequency-fractionmax-predicted-iterationsalign-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-heapsizeThe default is the smaller of RAM/8, RLIMIT_RSS, or a limit which
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 and 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-mem-true-dep-costselsched-max-lookaheadselsched-max-sched-timesselsched-max-insns-to-renamemax-last-value-rtlinteger-share-limitmin-virtual-mappingsvirtual-mappings-ratiossp-buffer-sizemax-jump-thread-duplication-stmtsmax-fields-for-field-sensitiveprefetch-latencysimultaneous-prefetchesl1-cache-line-sizel1-cache-sizel2-cache-sizemin-insn-to-prefetch-ratioprefetch-min-insn-to-mem-ratiouse-canonical-typesswitch-conversion-max-branch-ratiomax-partial-antic-lengthsccvn-max-scc-sizeira-max-loops-numira-max-conflict-table-sizeira-loop-reserved-regsloop-invariant-max-bbs-in-loopmax-vartrack-sizemin-nondebug-insn-uidipa-sra-ptr-growth-factorgraphite-max-nb-scop-paramsgraphite-max-bbs-per-functionloop-block-tile-sizedevirt-type-list-sizelto-partitionslto-minpartitioncxx-max-namespaces-for-diagnostic-help