Next:Program Instrumentation Options, Previous:Options for Debugging Your Program, Up:GCC Command Options [Contents][Index]
These options control various sorts of optimizations.
Without any optimization option, the compiler’s goal is to reduce thecost of compilation and to make debugging produce the expectedresults. Statements are independent: if you stop the program with abreakpoint between statements, you can then assign a new value to anyvariable or change the program counter to any other statement in thefunction and get exactly the results you expect from the sourcecode.
Turning on optimization flags makes the compiler attempt to improvethe performance and/or code size at the expense of compilation timeand possibly the ability to debug the program.
The compiler performs optimization based on the knowledge it has of theprogram. Compiling multiple files at once to a single output file mode allowsthe compiler to use information gained from all of the files when compilingeach of them.
Not all optimizations are controlled directly by a flag. Onlyoptimizations that have a flag are listed in this section.
Most optimizations are completely disabled at-O0 or if an-O level is not set on the command line, even if individualoptimization flags are specified. Similarly,-Og suppressesmany optimization passes.
Depending on the target and how GCC was configured, a slightly differentset of optimizations may be enabled at each-O level thanthose listed here. You can invoke GCC with-Q --help=optimizersto find out the exact set of optimizations that are enabled at each level.SeeOptions Controlling the Kind of Output, for examples.
-O ¶-O1--optimizeOptimize. Optimizing compilation takes somewhat more time, and a lotmore memory for a large function.
With-O, the compiler tries to reduce code size and executiontime, without performing any optimizations that take a great deal ofcompilation time.
-O is the recommended optimization level for large machine-generatedcode as a sensible balance between time taken to compile and memory use:higher optimization levels perform optimizations with greater algorithmiccomplexity than at-O.
-O turns on the following optimization flags:
-fauto-inc-dec-fbranch-count-reg-fcombine-stack-adjustments-fcompare-elim-fcprop-registers-fdce-fdefer-pop-fdelayed-branch-fdse-fforward-propagate-fguess-branch-probability-fif-conversion-fif-conversion2-finline-functions-called-once-fipa-modref-fipa-profile-fipa-pure-const-fipa-reference-fipa-reference-addressable-fivopts-fmerge-constants-fmove-loop-invariants-fmove-loop-stores-fomit-frame-pointer-freorder-blocks-fshrink-wrap-fshrink-wrap-separate-fsplit-wide-types-fssa-backprop-fssa-phiopt-ftree-bit-ccp-ftree-ccp-ftree-ch-ftree-coalesce-vars-ftree-copy-prop-ftree-dce-ftree-dominator-opts-ftree-dse-ftree-forwprop-ftree-fre-ftree-phiprop-ftree-pta-ftree-scev-cprop-ftree-sink-ftree-slsr-ftree-sra-ftree-ter-funit-at-a-time
-O2 ¶Optimize even more. GCC performs nearly all supported optimizationsthat do not involve a space-speed tradeoff.As compared to-O, this option increases both compilation timeand the performance of the generated code.
-O2 turns on all optimization flags specified by-O1. Italso turns on the following optimization flags:
-falign-functions -falign-jumps-falign-labels -falign-loops-fcaller-saves-fcode-hoisting-fcrossjumping-fcse-follow-jumps -fcse-skip-blocks-fdelete-null-pointer-checks -fdep-fusion-fdevirtualize -fdevirtualize-speculatively-fexpensive-optimizations-ffinite-loops-fgcse -fgcse-lm-fhoist-adjacent-loads-finline-functions-finline-small-functions-findirect-inlining-fipa-bit-cp -fipa-cp -fipa-icf-fipa-ra -fipa-sra -fipa-vrp-fisolate-erroneous-paths-dereference-flra-remat-foptimize-crc-foptimize-sibling-calls-foptimize-strlen-fpartial-inlining-fpeephole2-freorder-blocks-algorithm=stc-freorder-blocks-and-partition -freorder-functions-frerun-cse-after-loop-fschedule-insns -fschedule-insns2-fsched-interblock -fsched-spec-fspeculatively-call-stored-functions-fstore-merging-fstrict-aliasing-fthread-jumps-ftree-builtin-call-dce-ftree-loop-vectorize-ftree-pre-ftree-slp-vectorize-ftree-switch-conversion -ftree-tail-merge-ftree-vrp-fvect-cost-model=very-cheap
Please note the warning under-fgcse aboutinvoking-O2 on programs that use computed gotos.
-O3 ¶Optimize yet more.-O3 turns on all optimizations specifiedby-O2 and also turns on the following optimization flags:
-fgcse-after-reload-fipa-cp-clone-floop-interchange-floop-unroll-and-jam-fpeel-loops-fpredictive-commoning-fsplit-loops-fsplit-paths-ftree-loop-distribution-ftree-partial-pre-funswitch-loops-fvect-cost-model=dynamic-fversion-loops-for-strides
-O0 ¶Reduce compilation time and make debugging produce the expectedresults. This is the default.
At-O0, GCC completely disables most optimization passes;they are not run even if you explicitly enable them on the commandline, or are listed by-Q --help=optimizers as being enabled bydefault. Many optimizations performed by GCC depend on code analysisor canonicalization passes that are enabled by-O, and it wouldnot be useful to run individual optimization passes in isolation.
-Os ¶Optimize for size.-Os enables all-O2 optimizationsexcept those that often increase code size:
-falign-functions -falign-jumps-falign-labels -falign-loops-fprefetch-loop-arrays -freorder-blocks-algorithm=stc
It also enables-finline-functions, causes the compiler to tune forcode size rather than execution speed, and performs further optimizationsdesigned to reduce code size.
-Ofast ¶Disregard strict standards compliance.-Ofast enables all-O3 optimizations. It also enables optimizations that are notvalid for all standard-compliant programs.It turns on-ffast-math,-fallow-store-data-racesand the Fortran-specific-fstack-arrays, unless-fmax-stack-var-size is specified, and-fno-protect-parens.It turns off-fsemantic-interposition.
-Og ¶Optimize while keeping in mind debugging experience.-Og should be the optimizationlevel of choice for the standard edit-compile-debug cycle, offeringa reasonable blend of optimization, fast compilation and debugging experienceespecially for code with a high abstraction penalty. In contrast to-O0, this enables-fvar-tracking-assignments and-fvar-tracking which handle debug information in the prologueand epilogue of functions better than-O0.
Like-O0,-Og completely skips a number ofoptimization passes so that individual options controlling them haveno effect. Otherwise-Og enables all-O1optimization flags except for those known to greatly interfere with debugging:
-fbranch-count-reg -fdelayed-branch-fdse -fif-conversion -fif-conversion2-finline-functions-called-once-fmove-loop-invariants -fmove-loop-stores -fssa-phiopt-ftree-bit-ccp -ftree-dse -ftree-pta -ftree-sra
-Oz ¶Optimize aggressively for size rather than speed. This may increasethe number of instructions executed if those instructions requirefewer bytes to encode.-Oz behaves similarly to-Osincluding enabling most-O2 optimizations.
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-independentflags. Most flags have both positive and negative forms; the negativeform of-ffoo is-fno-foo. In the tablebelow, only one of the forms is listed—the one you typicallyuse. You can figure out the other form by either removing ‘no-’or adding it.
The following options control specific optimizations. They are eitheractivated by-O options or are related to ones that are. Youcan use the following flags in the rare cases when “fine-tuning” ofoptimizations to be performed is desired.
-fno-defer-pop ¶For machines that must pop arguments after a function call, always popthe arguments as soon as each function returns.At levels-O1 and higher,-fdefer-pop is the default;this allows the compiler to let arguments accumulate on the stack for severalfunction calls and pop them all at once.
-fforward-propagate ¶Perform a forward propagation pass on RTL. The pass tries to combine twoinstructions and checks if the result can be simplified. If loop unrollingis active, two passes are performed and the second is scheduled afterloop unrolling.
This option is enabled by default at optimization levels-O1,-O2,-O3,-Os.
-favoid-store-forwarding ¶-fno-avoid-store-forwardingMany CPUs will stall for many cycles when a load partially depends on previoussmaller stores. This pass tries to detect such cases and avoid the penalty bychanging the order of the load and store and then fixing up the loaded value.
Disabled by default.
-ffp-contract=style ¶-ffp-contract=off disables floating-point expression contraction.-ffp-contract=fast enables floating-point expression contractionsuch as forming of fused multiply-add operations if the target hasnative support for them.-ffp-contract=on enables floating-point expression contractionif allowed by the language standard. This is implemented for C and C++,where it enables contraction within one expression, but not acrossdifferent statements.
The default is-ffp-contract=off for C in a standards compliant mode(-std=c11 or similar),-ffp-contract=fast otherwise.
-ffp-int-builtin-inexact ¶Allow the built-in functionsceil,floor,round andtrunc, and theirfloat andlongdouble variants, to generate code that raises the “inexact”floating-point exception for noninteger arguments. ISO C99 and C11allow these functions to raise the “inexact” exception, but ISO/IECTS 18661-1:2014, the C bindings to IEEE 754-2008, as integrated intoISO C23, does not allow these functions to do so.
The default is-fno-fp-int-builtin-inexact, disallowing theexception to be raised, unless C17 or an earlier C standard is selected.This option does nothing unless-ftrapping-math is in effect.
Even if-fno-fp-int-builtin-inexact is used, if the functionsgenerate a call to a library function then the “inexact” exceptionmay be raised if the library implementation does not follow TS 18661.
-fomit-frame-pointer ¶Omit the frame pointer in functions that don’t need one. This avoids theinstructions to save, set up and restore the frame pointer; on many targetsit also makes an extra register available.
On some targets this flag has no effect because the standard calling sequencealways uses a frame pointer, so it cannot be omitted.
Note that-fno-omit-frame-pointer doesn’t guarantee the frame pointeris used in all functions. Several targets always omit the frame pointer inleaf functions.
Enabled by default at-O1 and higher.
-foptimize-crc ¶Detect loops calculating CRC (performing polynomial long division) andreplace them with a faster implementation. Detect 8, 16, 32, and 64 bit CRC,with a constant polynomial without the leading 1 bit,for both bit-forward and bit-reversed cases.If the target supports a CRC instruction and the polynomial used in the sourcecode matches the polynomial used in the CRC instruction, generate that CRCinstruction. Otherwise, if the target supports a carry-less-multiplicationinstruction, generate CRC using it; otherwise generate table-based CRC.
Enabled by default at-O2 and higher.
-foptimize-sibling-calls ¶Optimize sibling and tail recursive calls.
Enabled at levels-O2,-O3,-Os.
-foptimize-strlen ¶Optimize various standard C string functions (e.g.strlen,strchr orstrcpy) andtheir_FORTIFY_SOURCE counterparts into faster alternatives.
Enabled at levels-O2,-O3.
-finline-atomics ¶-fno-inline-atomicsInline ‘__atomic’ operations when a lock-free instruction sequenceis available. This optimization is enabled by default.
-finline-stringops[=fn] ¶Expand memory and string operations (for now, onlymemset)inline, even when the length is variable or big enough as to requirelooping. This is most useful along with-ffreestanding and-fno-builtin.
In some circumstances, it enables the compiler to generate code thattakes advantage of known alignment and length multipliers, but even thenit may be less efficient than optimized runtime implementations, andgrow code size so much that even a less performant but sharedimplementation runs faster due to better use of code caches. Thisoption is disabled by default.
-fno-inline ¶Do not expand any functions inline apart from those marked withthealways_inline attribute. This is the default when notoptimizing.
Single functions can be exempted from inlining by marking themwith thenoinline attribute.
-finline-small-functions ¶Integrate functions into their callers when their body is smaller than expectedfunction call code (so overall size of program gets smaller). The compilerheuristically decides which functions are simple enough to be worth integratingin this way. This inlining applies to all functions, even those not declaredinline.
Enabled at levels-O2,-O3,-Os.
-findirect-inlining ¶Inline also indirect calls that are discovered to be known at compiletime thanks to previous inlining. This option has any effect onlywhen inlining itself is turned on by the-finline-functionsor-finline-small-functions options.
Enabled at levels-O2,-O3,-Os.
-finline-functions ¶Consider all functions for inlining, even if they are not declared inline.The compiler heuristically decides which functions are worth integratingin this way.
If all calls to a given function are integrated, and the function isdeclaredstatic, then the function is normally not output asassembler code in its own right.
Enabled at levels-O2,-O3,-Os. Also enabledby-fprofile-use and-fauto-profile.
-finline-functions-called-once ¶Consider allstatic functions called once for inlining into theircaller even if they are not markedinline. If a call to a givenfunction is integrated, then the function is not output as assembler codein its own right.
Enabled at levels-O1,-O2,-O3 and-Os,but not-Og.
-fearly-inlining ¶Inline functions marked byalways_inline and functions whose body seemssmaller than the function call overhead early before doing-fprofile-generate instrumentation and real inlining pass. Doing somakes profiling significantly cheaper and usually inlining faster on programshaving large chains of nested wrapper functions.
Enabled by default.
-fipa-sra ¶Perform interprocedural scalar replacement of aggregates, removal ofunused parameters and replacement of parameters passed by referenceby parameters passed by value.
Enabled at levels-O2,-O3 and-Os.
-finline-limit=n ¶By default, GCC limits the size of functions that can be inlined. This flagallows coarse control of this limit.n is the size of functions thatcan be inlined in number of pseudo instructions.
Inlining is actually controlled by a number of internal parameters, whichare documented in the GCC Internals manual and should not normally be setdirectly.
Note: there may be no value to-finline-limit that resultsin default behavior.
Note: pseudo instruction represents, in this particular context, anabstract measurement of function’s size. In no way does it represent a countof assembly instructions and as such its exact meaning might change from onerelease to an another.
-fno-keep-inline-dllexport ¶This is a more fine-grained version of-fkeep-inline-functions,which applies only to functions that are declared using thedllexportattribute or declspec. SeeDeclaring Attributes ofFunctions.
-fkeep-inline-functions ¶In C, emitstatic functions that are declaredinlineinto the object file, even if the function has been inlined into allof its callers. This switch does not affect functions using theextern inline extension in GNU C90. In C++, emit any and allinline functions into the object file.
-fkeep-static-functions ¶Emitstatic functions into the object file, even if the functionis never used.
-fkeep-static-consts ¶Emit variables declaredstatic const when optimization isn’t turnedon, even if the variables aren’t referenced.
GCC enables this option by default. If you want to force the compiler tocheck if a variable is referenced, regardless of whether or notoptimization is turned on, use the-fno-keep-static-consts option.
-fmerge-constants ¶Attempt to merge identical constants (string constants and floating-pointconstants) across compilation units.
This option is the default for optimized compilation if the assembler andlinker support it. Use-fno-merge-constants to inhibit thisbehavior.
Enabled at levels-O1,-O2,-O3,-Os.
-fmerge-all-constants ¶Attempt to merge identical constants and identical variables.
This option implies-fmerge-constants. In addition to-fmerge-constants this considers e.g. even constant initializedarrays or initialized constant variables with integral or floating-pointtypes. Languages like C or C++ require each variable, including multipleinstances of the same variable in recursive calls, to have distinct locations,so using this option results in non-conformingbehavior.
-fmodulo-sched ¶Perform swing modulo scheduling immediately before the first schedulingpass. This pass looks at innermost loops and reorders theirinstructions by overlapping different iterations.
-fmodulo-sched-allow-regmoves ¶Perform more aggressive SMS-based modulo scheduling with register movesallowed. By setting this flag certain anti-dependences edges aredeleted, which triggers the generation of reg-moves based on thelife-range analysis. This option is effective only with-fmodulo-sched enabled.
-fno-branch-count-reg ¶Disable the optimization pass that scans for opportunities to use“decrement and branch” instructions on a count register instead ofinstruction sequences that decrement a register, compare it against zero, andthen branch based upon the result. This option is only meaningful onarchitectures that support such instructions, which include x86, PowerPC,IA-64 and S/390. Note that the-fno-branch-count-reg optiondoesn’t remove the decrement and branch instructions from the generatedinstruction stream introduced by other optimization passes.
The default is-fbranch-count-reg at-O1 and higher,except for-Og.
-fno-function-cse ¶Do not put function addresses in registers; make each instruction thatcalls a constant function contain the function’s address explicitly.
This option results in less efficient code, but some strange hacksthat alter the assembler output may be confused by the optimizationsperformed when this option is not used.
The default is-ffunction-cse
-ffuse-ops-with-volatile-access ¶Allow limited optimization of operations with volatile memory accesswhen doing so does not change the semantics outlined inSeeWhen is a Volatile Object Accessed?.
The default is-ffuse-ops-with-volatile-access
-fno-zero-initialized-in-bss ¶If the target supports a BSS section, GCC by default puts variables thatare initialized to zero into BSS. This can save space in the resultingcode.
This option turns off this behavior because some programs explicitlyrely on variables going to the data section—e.g., so that theresulting executable can find the beginning of that section and/or makeassumptions based on that.
The default is-fzero-initialized-in-bss except in Ada.
-fthread-jumps ¶Perform optimizations that check to see if a jump branches to alocation where another comparison subsumed by the first is found. Ifso, the first branch is redirected to either the destination of thesecond branch or a point immediately following it, depending on whetherthe condition is known to be true or false.
Enabled at levels-O1,-O2,-O3,-Os.
-fsplit-wide-types ¶When using a type that occupies multiple registers, such aslonglong on a 32-bit system, split the registers apart and allocate themindependently. This normally generates better code for those types,but may make debugging more difficult.
Enabled at levels-O1,-O2,-O3,-Os.
-fsplit-wide-types-early ¶Fully split wide types early, instead of very late.This option has no effect unless-fsplit-wide-types is turned on.
This is the default on some targets.
-fcse-follow-jumps ¶In common subexpression elimination (CSE), scan through jump instructionswhen the target of the jump is not reached by any other path. Forexample, when CSE encounters anif statement with anelse clause, CSE follows the jump when the conditiontested is false.
Enabled at levels-O2,-O3,-Os.
-fcse-skip-blocks ¶This is similar to-fcse-follow-jumps, but causes CSE tofollow jumps that conditionally skip over blocks. When CSEencounters a simpleif statement with no else clause,-fcse-skip-blocks causes CSE to follow the jump around thebody of theif.
Enabled at levels-O2,-O3,-Os.
-frerun-cse-after-loop ¶Re-run common subexpression elimination after loop optimizations areperformed.
Enabled at levels-O2,-O3,-Os.
-fgcse ¶Perform a global common subexpression elimination pass.This pass also performs global constant and copy propagation.
Note: When compiling a program using computed gotos, a GCCextension, you may get better run-time performance if you disablethe global common subexpression elimination pass by adding-fno-gcse to the command line.
Enabled at levels-O2,-O3,-Os.
-fgcse-lm ¶When-fgcse-lm is enabled, global common subexpression eliminationattempts to move loads that are only killed by stores into themselves. Thisallows a loop containing a load/store sequence to be changed to a load outsidethe loop, and a copy/store within the loop.
Enabled by default when-fgcse is enabled.
-fgcse-sm ¶When-fgcse-sm is enabled, a store motion pass is run afterglobal common subexpression elimination. This pass attempts to movestores out of loops. When used in conjunction with-fgcse-lm,loops containing a load/store sequence can be changed to a load beforethe loop and a store after the loop.
Not enabled at any optimization level.
-fgcse-las ¶When-fgcse-las is enabled, the global common subexpressionelimination pass eliminates redundant loads that come after stores to thesame memory location (both partial and full redundancies).
Not enabled at any optimization level.
-fgcse-after-reload ¶When-fgcse-after-reload is enabled, a redundant load eliminationpass is performed after reload. The purpose of this pass is to clean upredundant spilling.
Enabled by-O3,-fprofile-use and-fauto-profile.
-faggressive-loop-optimizations ¶This option tells the loop optimizer to use language constraints toderive bounds for the number of iterations of a loop. This assumes thatloop code does not invoke undefined behavior by for example causing signedinteger overflows or out-of-bound array accesses. The bounds for thenumber of iterations of a loop are used to guide loop unrolling and peelingand loop exit test optimizations.This option is enabled by default.
-funconstrained-commons ¶This option tells the compiler that variables declared in common blocks(e.g. Fortran) may later be overridden with longer trailing arrays. Thisprevents certain optimizations that depend on knowing the array bounds.
-fcrossjumping ¶Perform cross-jumping transformation.This transformation unifies equivalent code and saves code size. Theresulting code may or may not perform better than without cross-jumping.
Enabled at levels-O2,-O3,-Os.
-fauto-inc-dec ¶Combine increments or decrements of addresses with memory accesses.This pass is always skipped on architectures that do not haveinstructions to support this. Enabled by default at-O1 andhigher on architectures that support this.
-fdce ¶Perform dead code elimination (DCE) on RTL.Enabled by default at-O1 and higher.
-fdse ¶Perform dead store elimination (DSE) on RTL.Enabled by default at-O1 and higher.
-fif-conversion ¶Attempt to transform conditional jumps into branch-less equivalents. Thisincludes use of conditional moves, min, max, set flags and abs instructions, andsome tricks doable by standard arithmetics. The use of conditional executionon chips where it is available is controlled by-fif-conversion2.
Enabled at levels-O1,-O2,-O3,-Os, butnot with-Og.
-fif-conversion2 ¶Use conditional execution (where available) to transform conditional jumps intobranch-less equivalents.
Enabled at levels-O1,-O2,-O3,-Os, butnot with-Og.
-fdeclone-ctor-dtor ¶The C++ ABI requires multiple entry points for constructors anddestructors: one for a base subobject, one for a complete object, andone for a virtual destructor that calls operator delete afterwards.For a hierarchy with virtual bases, the base and complete variants areclones, which means two copies of the function. With this option, thebase and complete variants are changed to be thunks that call a commonimplementation.
Enabled by-Os.
-fdelete-null-pointer-checks ¶Assume that programs cannot safely dereference null pointers, and thatno code or data element resides at address zero.This option enables simple constantfolding optimizations at all optimization levels. In addition, otheroptimization passes in GCC use this flag to control global dataflowanalyses that eliminate useless checks for null pointers; these assumethat a memory access to address zero always results in a trap, sothat if a pointer is checked after it has already been dereferenced,it cannot be null.
Note however that in some environments this assumption is not true.Use-fno-delete-null-pointer-checks to disable this optimizationfor programs that depend on that behavior.
This option is enabled by default on most targets.On AVR and MSP430, this option is completely disabled.
Passes that use the dataflow informationare enabled independently at different optimization levels.
-fdevirtualize ¶Attempt to convert calls to virtual functions to direct calls. Thisis done both within a procedure and interprocedurally as part ofindirect inlining (-findirect-inlining) and interprocedural constantpropagation (-fipa-cp).Enabled at levels-O2,-O3,-Os.
-fdevirtualize-speculatively ¶Attempt to convert calls to virtual functions to speculative direct calls.Based on the analysis of the type inheritance graph, determine for a given callthe set of likely targets. If the set is small, preferably of size 1, changethe call into a conditional deciding between direct and indirect calls. Thespeculative calls enable more optimizations, such as inlining. When they seemuseless after further optimization, they are converted back into original form.
-fdevirtualize-at-ltrans ¶Stream extra information needed for aggressive devirtualization when runningthe link-time optimizer in local transformation mode.This option enables more devirtualization butsignificantly increases the size of streamed data. For this reason it isdisabled by default.
-fexpensive-optimizations ¶Perform a number of minor optimizations that are relatively expensive.
Enabled at levels-O2,-O3,-Os.
-fext-dce ¶-fno-ext-dcePerform dead code elimination on zero and sign extensions, with specialdataflow analysis.
-free ¶Attempt to remove redundant extension instructions. This is especiallyhelpful for the x86-64 architecture, which implicitly zero-extends in 64-bitregisters after writing to their lower 32-bit half.
Enabled for Alpha, AArch64, LoongArch, PowerPC, RISC-V, SPARC, h83000 and x86 atlevels-O2,-O3,-Os.
-fno-lifetime-dse ¶In C++ the value of an object is only affected by changes within itslifetime: when the constructor begins, the object has an indeterminatevalue, and any changes during the lifetime of the object are dead whenthe object is destroyed. Normally dead store elimination will takeadvantage of this; if your code relies on the value of the objectstorage persisting beyond the lifetime of the object, you can use thisflag to disable this optimization. To preserve stores before theconstructor starts (e.g. because your operator new clears the objectstorage) but still treat the object as dead after the destructor, youcan use-flifetime-dse=1. The default behavior can beexplicitly selected with-flifetime-dse=2.-flifetime-dse=0 is equivalent to-fno-lifetime-dse.
-flive-range-shrinkage ¶Attempt to decrease register pressure through register live rangeshrinkage. This is helpful for fast processors with small or moderatesize register sets.
-fira-algorithm=algorithm ¶Use the specified coloring algorithm for the integrated registerallocator. Thealgorithm argument can be ‘priority’, whichspecifies Chow’s priority coloring, or ‘CB’, which specifiesChaitin-Briggs coloring. Chaitin-Briggs coloring is not implementedfor all architectures, but for those targets that do support it, it isthe default because it generates better code.
-fira-region=region ¶Use specified regions for the integrated register allocator. Theregion argument should be one of the following:
Use all loops as register allocation regions.This can give the best results for machines with a small and/orirregular register set.
Use all loops except for loops with small register pressureas the regions. This value usually givesthe best results in most cases and for most architectures,and is enabled by default when compiling with optimization for speed(-O,-O2, …).
Use all functions as a single region.This typically results in the smallest code size, and is enabled by default for-Os or-O0.
-fira-hoist-pressure ¶Use IRA to evaluate register pressure in the code hoisting pass fordecisions to hoist expressions. This option usually results in smallercode, but it can slow the compiler down.
This option is enabled at level-Os for all targets.
-fira-loop-pressure ¶Use IRA to evaluate register pressure in loops for decisions to moveloop invariants. This option usually results in generationof faster and smaller code on machines with large register files (>= 32registers), but it can slow the compiler down.
This option is enabled at level-O3 for some targets.
-fno-ira-share-save-slots ¶Disable sharing of stack slots used for saving call-used hardregisters living through a call. Each hard register gets aseparate stack slot, and as a result function stack frames arelarger.
-fno-ira-share-spill-slots ¶Disable sharing of stack slots allocated for pseudo-registers. Eachpseudo-register that does not get a hard register gets a separatestack slot, and as a result function stack frames are larger.
-flra-remat ¶Enable CFG-sensitive rematerialization in LRA. Instead of loadingvalues of spilled pseudos, LRA tries to rematerialize (recalculate)values if it is profitable.
Enabled at levels-O2,-O3,-Os.
-fdelayed-branch ¶If supported for the target machine, attempt to reorder instructionsto exploit instruction slots available after delayed branchinstructions.
Enabled at levels-O1,-O2,-O3,-Os,but not at-Og.
-fschedule-insns ¶If supported for the target machine, attempt to reorder instructions toeliminate execution stalls due to required data being unavailable. Thishelps machines that have slow floating point or memory load instructionsby allowing other instructions to be issued until the result of the loador floating-point instruction is required.
Conventionally enabled at optimization levels-O2 and-O3.However, many targets override this behavior. For example, on x86, it isdisabled at all levels, while on AArch64, it is enabled only at-O3.
-fschedule-insns2 ¶Similar to-fschedule-insns, but requests an additional pass ofinstruction scheduling after register allocation has been done. This isespecially useful on machines with a relatively small number ofregisters and where memory load instructions take more than one cycle.
Enabled at levels-O2,-O3,-Os.
-fno-sched-interblock ¶Disable instruction scheduling across basic blocks, whichis normally enabled when scheduling before register allocation, i.e.with-fschedule-insns or at-O2 or higher.
-fno-sched-spec ¶Disable speculative motion of non-load instructions, whichis normally enabled when scheduling before register allocation, i.e.with-fschedule-insns or at-O2 or higher.
-fsched-pressure ¶Enable register pressure sensitive insn scheduling before registerallocation. This only makes sense when scheduling before registerallocation is enabled, i.e. with-fschedule-insns or at-O2 or higher. Usage of this option can improve thegenerated code and decrease its size by preventing register pressureincrease above the number of available hard registers and subsequentspills in register allocation.
-fsched-spec-load ¶Allow speculative motion of some load instructions. This only makessense when scheduling before register allocation, i.e. with-fschedule-insns or at-O2 or higher.
-fsched-spec-load-dangerous ¶Allow speculative motion of more load instructions. This only makessense when scheduling before register allocation, i.e. with-fschedule-insns or at-O2 or higher.
-fsched-stalled-insns ¶-fsched-stalled-insns=nDefine how many insns (if any) can be moved prematurely from the queueof stalled insns into the ready list during the second scheduling pass.-fno-sched-stalled-insns means that no insns are movedprematurely,-fsched-stalled-insns=0 means there is no limiton 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=nDefine how many insn groups (cycles) are examined for a dependencyon a stalled insn that is a candidate for premature removal from the queueof stalled insns. This has an effect only during the second scheduling pass,and only if-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-superblocks ¶When scheduling after register allocation, use superblock scheduling.This allows motion across basic block boundaries,resulting in faster schedules. This option is experimental, as not all machinedescriptions used by GCC model the CPU closely enough to avoid unreliableresults from the algorithm.
This only makes sense when scheduling after register allocation, i.e. with-fschedule-insns2 or at-O2 or higher.
-fsched-group-heuristic ¶Enable the group heuristic in the scheduler. This heuristic favorsthe instruction that belongs to a schedule group. This is enabledby default when scheduling is enabled, i.e. with-fschedule-insnsor-fschedule-insns2 or at-O2 or higher.
-fsched-critical-path-heuristic ¶Enable the critical-path heuristic in the scheduler. This heuristic favorsinstructions on the critical path. This is enabled by default whenscheduling is enabled, i.e. with-fschedule-insnsor-fschedule-insns2 or at-O2 or higher.
-fsched-spec-insn-heuristic ¶Enable the speculative instruction heuristic in the scheduler. Thisheuristic favors speculative instructions with greater dependency weakness.This is enabled by default when scheduling is enabled, i.e.with-fschedule-insns or-fschedule-insns2or at-O2 or higher.
-fsched-rank-heuristic ¶Enable the rank heuristic in the scheduler. This heuristic favorsthe instruction belonging to a basic block with greater size or frequency.This is enabled by default when scheduling is enabled, i.e.with-fschedule-insns or-fschedule-insns2 orat-O2 or higher.
-fsched-last-insn-heuristic ¶Enable the last-instruction heuristic in the scheduler. This heuristicfavors the instruction that is less dependent on the last instructionscheduled. This is enabled by default when scheduling is enabled,i.e. with-fschedule-insns or-fschedule-insns2 orat-O2 or higher.
-fsched-dep-count-heuristic ¶Enable the dependent-count heuristic in the scheduler. This heuristicfavors the instruction that has more instructions depending on it.This is enabled by default when scheduling is enabled, i.e.with-fschedule-insns or-fschedule-insns2 orat-O2 or higher.
-fspeculatively-call-stored-functions ¶Attempt to convert indirect calls of function pointers to pointersloaded from a structure field if all visible stores to that field storejust a single candidate. When doing so, turn the call into aconditional deciding between the direct call and the original indirectone. These speculative calls often enable more optimizations, such asinlining. When they seem useless after further optimization, they areconverted back into original form.
-freschedule-modulo-scheduled-loops ¶Modulo scheduling is performed before traditional scheduling. If a loopis modulo scheduled, later scheduling passes may change its schedule.Use this option to control that behavior.
-fselective-scheduling ¶Schedule instructions using selective scheduling algorithm. Selectivescheduling runs instead of the first scheduler pass.
-fselective-scheduling2 ¶Schedule instructions using selective scheduling algorithm. Selectivescheduling runs instead of the second scheduler pass.
-fsel-sched-pipelining ¶Enable software pipelining of innermost loops during selective scheduling.This option has no effect unless one of-fselective-scheduling or-fselective-scheduling2 is turned on.
-fsel-sched-pipelining-outer-loops ¶When pipelining loops during selective scheduling, also pipeline outer loops.This option has no effect unless-fsel-sched-pipelining is turned on.
-fsemantic-interposition ¶Some object formats, like ELF, allow interposing of symbols by thedynamic linker.This means that for symbols exported from the DSO, the compiler cannot performinterprocedural propagation, inlining and other optimizations in anticipationthat the function or variable in question may change. While this feature isuseful, for example, to rewrite memory allocation functions by a debuggingimplementation, it is expensive in the terms of code quality.With-fno-semantic-interposition the compiler assumes thatif interposition happens for functions the overwriting function will haveprecisely the same semantics (and side effects).Similarly if interposition happensfor variables, the constructor of the variable will be the same. The flaghas no effect for functions explicitly declared inline(where it is never allowed for interposition to change semantics)and for symbols explicitly declared weak.
-fshrink-wrap ¶Emit function prologues only before parts of the function that need it,rather than at the top of the function. This flag is enabled by default at-O and higher.
-fshrink-wrap-separate ¶Shrink-wrap separate parts of the prologue and epilogue separately, so thatthose parts are only executed when needed.This option is on by default, but has no effect unless-fshrink-wrapis also turned on and the target supports this.
-fcaller-saves ¶Enable allocation of values to registers that are clobbered byfunction calls, by emitting extra instructions to save and restore theregisters around such calls. Such allocation is done only when itseems to result in better code.
This option is always enabled by default on certain machines, usuallythose which have no call-preserved registers to use instead.
Enabled at levels-O2,-O3,-Os.
-fcombine-stack-adjustments ¶Tracks stack adjustments (pushes and pops) and stack memory referencesand then tries to find ways to combine them.
Enabled by default at-O1 and higher.
-fipa-ra ¶Use caller save registers for allocation if those registers are not used byany called function. In that case it is not necessary to save and restorethem around calls. This is only possible if called functions are part ofsame compilation unit as current function and they are compiled before it.
Enabled at levels-O2,-O3,-Os, however the optionis disabled if generated code will be instrumented for profiling(-p, or-pg) or if callee’s register usage cannot be knownexactly (this happens on targets that do not expose prologuesand epilogues in RTL).
-fconserve-stack ¶Attempt to minimize stack usage. The compiler attempts to use lessstack space, even if that makes the program slower. This optionimplies setting thelarge-stack-frame parameter to 100and thelarge-stack-frame-growth parameter to 400.
-ftree-reassoc ¶Perform reassociation on trees. This flag is enabled by defaultat-O1 and higher.
-fcode-hoisting ¶Perform code hoisting. Code hoisting tries to move theevaluation of expressions executed on all paths to the function exitas early as possible. This is especially useful as a code sizeoptimization, but it often helps for code speed as well.This flag is enabled by default at-O2 and higher.
-ftree-pre ¶Perform partial redundancy elimination (PRE) on trees. This flag isenabled by default at-O2 and-O3.
-ftree-partial-pre ¶Make partial redundancy elimination (PRE) more aggressive. This flag isenabled by default at-O3.
-ftree-forwprop ¶Perform forward propagation on trees. This flag is enabled by defaultat-O1 and higher.
-ftree-fre ¶Perform full redundancy elimination (FRE) on trees. The differencebetween FRE and PRE is that FRE only considers expressionsthat are computed on all paths leading to the redundant computation.This analysis is faster than PRE, though it exposes fewer redundancies.This flag is enabled by default at-O1 and higher.
-ftree-phiprop ¶Perform hoisting of loads from conditional pointers on trees. Thispass is enabled by default at-O1 and higher.
-fhoist-adjacent-loads ¶Speculatively hoist loads from both branches of an if-then-else if theloads are from adjacent locations in the same structure and the targetarchitecture has a conditional move instruction. This flag is enabledby default at-O2 and higher.
-ftree-copy-prop ¶Perform copy propagation on trees. This pass eliminates unnecessarycopy operations. This flag is enabled by default at-O1 andhigher.
-fipa-pure-const ¶Discover which functions are pure or constant.Enabled by default at-O1 and higher.
-fipa-reference ¶Discover which static variables do not escape thecompilation unit.Enabled by default at-O1 and higher.
-fipa-reference-addressable ¶Discover read-only, write-only and non-addressable static variables.Enabled by default at-O1 and higher.
-fipa-reorder-for-locality ¶Group call chains close together in the binary layout to improve codelocality and minimize jump distances between frequently called functions.Unlike-freorder-functions this pass considers the callchains between functions and groups them together, rather than grouping allhot/normal/cold/never-executed functions into separate sections.Unlike-fprofile-reorder-functions it aims to improve code localitythroughout the runtime of the program rather than focusing on program startup.This option is incompatible with an explicit-flto-partition= option since it enforces a custom partitioningscheme.If using this option it is recommended to also use profile feedback, but thisoption is not enabled by default otherwise.
-fipa-stack-alignment ¶Reduce stack alignment on call sites if possible.Enabled by default.
-fipa-pta ¶Perform interprocedural pointer analysis and interprocedural modificationand reference analysis. This option can cause excessive memory andcompile-time usage on large compilation units. It is not enabled bydefault at any optimization level.
-fipa-profile ¶Perform interprocedural profile propagation. The functions called only fromcold functions are marked as cold. Also functions executed once (such ascold,noreturn, static constructors or destructors) areidentified. Cold functions and loop less parts of functions executed once arethen optimized for size.Enabled by default at-O1 and higher.
-fipa-modref ¶Perform interprocedural mod/ref analysis. This optimization analyzes the sideeffects of functions (memory locations that are modified or referenced) andenables better optimization across the function call boundary. This flag isenabled by default at-O1 and higher.
-fipa-cp ¶Perform interprocedural constant propagation.This optimization analyzes the program to determine when values passedto functions are constants and then optimizes accordingly.This optimization can substantially increase performanceif the application has constants passed to functions.This flag is enabled by default at-O2,-Os and-O3.It is also enabled by-fprofile-use and-fauto-profile.
-fipa-cp-clone ¶Perform function cloning to make interprocedural constant propagation stronger.When enabled, interprocedural constant propagation performs function cloningwhen externally visible function can be called with constant arguments.Because this optimization can create multiple copies of functions,it may significantly increase code size.This flag is enabled by default at-O3.It is also enabled by-fprofile-use and-fauto-profile.
-fipa-bit-cp ¶When enabled, perform interprocedural bitwise constantpropagation. This flag is enabled by default at-O2 andby-fprofile-use and-fauto-profile.It requires that-fipa-cp is enabled.
-fipa-vrp ¶When enabled, perform interprocedural propagation of valueranges. This flag is enabled by default at-O2. It requiresthat-fipa-cp is enabled.
-fipa-icf-functions ¶-fipa-icf-variables-fipa-icfPerform Identical Code Folding for functions (-fipa-icf-functions),read-only variables (-fipa-icf-variables), or both(-fipa-icf).The optimization reduces code size and may disturb unwind stacks by replacinga function by an equivalent one with a different name. The optimization worksmore effectively with link-time optimization enabled.
Although the behavior is similar to the Gold Linker’s ICF optimization, GCC ICFworks on different levels and thus the optimizations are not same - there areequivalences that are found only by GCC and equivalences found only by Gold.
-fipa-icf is enabled by default at-O2 and-Os.
-flate-combine-instructions ¶Enable two instruction combination passes that run relatively late in thecompilation process. One of the passes runs before register allocation andthe other after register allocation. The main aim of the passes is tosubstitute definitions into all uses.
Most targets enable this flag by default at-O2 and-Os.
-flive-patching=level ¶Control GCC’s optimizations to produce output suitable for live-patching.
If the compiler’s optimization uses a function’s body or information extractedfrom its body to optimize/change another function, the latter is called animpacted function of the former. If a function is patched, its impactedfunctions should be patched too.
The impacted functions are determined by the compiler’s interproceduraloptimizations. For example, a caller is impacted when inlining a functioninto its caller,cloning a function and changing its caller to call this new clone,or extracting a function’s pureness/constness information to optimizeits direct or indirect callers, etc.
Usually, the more IPA optimizations enabled, the larger the number ofimpacted functions for each function. In order to control the number ofimpacted functions and more easily compute the list of impacted function,IPA optimizations can be partially enabled at two different levels.
Thelevel argument should be one of the following:
Only enable inlining and cloning optimizations, which includes inlining,cloning, interprocedural scalar replacement of aggregates and partial inlining.As a result, when patching a function, all its callers and its clones’callers are impacted, therefore need to be patched as well.
-flive-patching=inline-clone disables the following optimization flags:
-fwhole-program -fipa-pta -fipa-reference -fipa-ra-fipa-icf -fipa-icf-functions -fipa-icf-variables-fipa-bit-cp -fipa-vrp -fipa-pure-const-fipa-reference-addressable-fipa-stack-alignment -fipa-modref
Only enable inlining of static functions.As a result, when patching a static function, all its callers are impactedand so need to be patched as well.
In addition to all the flags that-flive-patching=inline-clonedisables,-flive-patching=inline-only-static disables the following additionaloptimization flags:
-fipa-cp-clone -fipa-sra -fpartial-inlining -fipa-cp
When-flive-patching is specified without any value, the default valueisinline-clone.
This flag is disabled by default.
Note that-flive-patching is not supported with link-time optimization(-flto).
-fisolate-erroneous-paths-dereference ¶Detect paths that trigger erroneous or undefined behavior due todereferencing a null pointer (with-fdelete-null-pointer-checksenabled) or a division by zero. Isolate those paths from the main controlflow and turn the statement with erroneous or undefined behavior into atrap. This flag is enabled by default at-O2 and higher.
-fisolate-erroneous-paths-attribute ¶Detect paths that trigger erroneous or undefined behavior due to a null valuebeing used in a way forbidden by areturns_nonnull ornonnullattribute. Isolate those paths from the main control flow and turn thestatement with erroneous or undefined behavior into a trap. This is notcurrently enabled, but may be enabled by-O2 in the future.
-ftree-sink ¶Perform forward store motion on trees. This flag isenabled by default at-O1 and higher.
-ftree-bit-ccp ¶Perform sparse conditional bit constant propagation on trees and propagatepointer alignment information.This pass only operates on local scalar variables and is enabled by defaultat-O1 and higher, except for-Og.It requires that-ftree-ccp is enabled.
-ftree-ccp ¶Perform sparse conditional constant propagation (CCP) on trees. Thispass only operates on local scalar variables and is enabled by defaultat-O1 and higher.
-fssa-backprop ¶Propagate information about uses of a value up the definition chainin order to simplify the definitions. For example, this pass stripssign operations if the sign of a value never matters. The flag isenabled by default at-O1 and higher.
-fssa-phiopt ¶Perform pattern matching on SSA PHI nodes to optimize conditionalcode. This pass is enabled by default at-O1 and higher,except for-Og.
-ftree-switch-conversion ¶Perform conversion of simple initializations in a switch toinitializations from a scalar array. This flag is enabled by defaultat-O2 and higher.
-ftree-tail-merge ¶Look for identical code sequences. When found, replace one with a jump to theother. This optimization is known as tail merging or cross jumping. This flagis enabled by default at-O2 and higher. The compilation timein this pass canbe limited usingmax-tail-merge-comparisons parameter andmax-tail-merge-iterations parameter.
-ftree-cselim ¶Perform conditional store elimination on trees. This flag is enabled bydefault at-O1 and higher on targets that have conditionalmove instructions.
-ftree-dce ¶Perform dead code elimination (DCE) on trees. This flag is enabled bydefault at-O1 and higher.
-ftree-builtin-call-dce ¶Perform conditional dead code elimination (DCE) for calls to built-in functionsthat may seterrno but are otherwise free of side effects. This flag isenabled by default at-O2 and higher if-Os is not alsospecified.
-ffinite-loops ¶Assume that a loop with an exit will eventually take the exit and not loopindefinitely. This allows the compiler to remove loops that otherwise haveno side-effects, not considering eventual endless looping as such.
This option is enabled by default at-O2 for C++ with -std=c++11or higher.
-ftree-dominator-opts ¶Perform a variety of simple scalar cleanups (constant/copypropagation, redundancy elimination, range propagation and expressionsimplification) based on a dominator tree traversal. This alsoperforms jump threading (to reduce jumps to jumps). This flag isenabled by default at-O1 and higher.
-ftree-dse ¶Perform dead store elimination (DSE) on trees. A dead store is a store intoa memory location that is later overwritten by another store withoutany intervening loads. In this case the earlier store can be deleted. Thisflag is enabled by default at-O1 and higher.
-ftree-ch ¶Perform loop header copying on trees. This is beneficial since it increaseseffectiveness of code motion optimizations. It also saves one jump. This flagis enabled by default at-O1 and higher. It is not enabledfor-Os, since it usually increases code size.
-ftree-loop-optimize ¶Perform loop optimizations on trees. This flag is enabled by defaultat-O1 and higher.
-ftree-loop-linear ¶-floop-strip-mine-floop-blockPerform loop nest optimizations. Same as-floop-nest-optimize. To use this code transformation, GCC hasto be configured with--with-isl to enable the Graphite looptransformation infrastructure.
-fgraphite-identity ¶Enable the identity transformation for graphite. For every SCoP we generatethe polyhedral representation and transform it back to gimple. Using-fgraphite-identity we can check the costs or benefits of theGIMPLE -> GRAPHITE -> GIMPLE transformation. Some minimal optimizationsare also performed by the code generator isl, like index splitting anddead code elimination in loops.
-floop-nest-optimize ¶Enable the isl based loop nest optimizer. This is a generic loop nestoptimizer based on the Pluto optimization algorithms. It calculates a loopstructure optimized for data-locality and parallelism. This optionis experimental.
-floop-parallelize-all ¶Use the Graphite data dependence analysis to identify loops that canbe parallelized. Parallelize all the loops that can be analyzed tonot contain loop carried dependences without checking that it isprofitable to parallelize the loops.
-ftree-coalesce-vars ¶While transforming the program out of the SSA representation, attempt toreduce copying by coalescing versions of different user-definedvariables, instead of just compiler temporaries. This may severelylimit the ability to debug an optimized program compiled with-fno-var-tracking-assignments. In the negated form, this flagprevents SSA coalescing of user variables. This option is enabled bydefault if optimization is enabled, and it does very little otherwise.
-ftree-loop-if-convert ¶Attempt to transform conditional jumps in the innermost loops tobranch-less equivalents. The intent is to remove control-flow fromthe innermost loops in order to improve the ability of thevectorization pass to handle these loops. This is enabled by defaultif vectorization is enabled.
-ftree-loop-distribution ¶Perform loop distribution. This flag can improve cache performance onbig loop bodies and allow further loop optimizations, likeparallelization or vectorization, to take place. For example, the loop
DO I = 1, N A(I) = B(I) + C D(I) = E(I) * FENDDO
is transformed to
DO I = 1, N A(I) = B(I) + CENDDODO I = 1, N D(I) = E(I) * FENDDO
This flag is enabled by default at-O3.It is also enabled by-fprofile-use and-fauto-profile.
-ftree-loop-distribute-patterns ¶Perform loop distribution of patterns that can be code generated withcalls to a library. This flag is enabled by default at-O2 andhigher, and by-fprofile-use and-fauto-profile.
This pass distributes the initialization loops and generates a call tomemset zero. For example, the loop
DO I = 1, N A(I) = 0 B(I) = A(I) + IENDDO
is transformed to
DO I = 1, N A(I) = 0ENDDODO I = 1, N B(I) = A(I) + IENDDO
and the initialization loop is transformed into a call to memset zero.
-floop-interchange ¶Perform loop interchange outside of graphite. This flag can improve cacheperformance on loop nest and allow further loop optimizations, likevectorization, to take place. For example, the loop
for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) for (int k = 0; k < N; k++) c[i][j] = c[i][j] + a[i][k]*b[k][j];
is transformed to
for (int i = 0; i < N; i++) for (int k = 0; k < N; k++) for (int j = 0; j < N; j++) c[i][j] = c[i][j] + a[i][k]*b[k][j];
This flag is enabled by default at-O3.It is also enabled by-fprofile-use and-fauto-profile.
-floop-unroll-and-jam ¶Apply unroll and jam transformations on feasible loops. In a loopnest this unrolls the outer loop by some factor and fuses the resultingmultiple inner loops. This flag is enabled by default at-O3.It is also enabled by-fprofile-use and-fauto-profile.
-ftree-loop-im ¶Perform loop invariant motion on trees. This pass moves only invariants thatare hard to handle at RTL level (function calls, operations that expand tonontrivial sequences of insns). With-funswitch-loops it also movesoperands of conditions that are invariant out of the loop, so that we can usejust trivial invariantness analysis in loop unswitching. The pass also includesstore motion.
-ftree-loop-ivcanon ¶Create a canonical counter for number of iterations in loops for whichdetermining number of iterations requires complicated analysis. Lateroptimizations then may determine the number easily. Useful especiallyin connection with unrolling.
-ftree-scev-cprop ¶Perform final value replacement. If a variable is modified in a loopin such a way that its value when exiting the loop can be determined usingonly its initial value and the number of loop iterations, replace uses ofthe final value by such a computation, provided it is sufficiently cheap.This reduces data dependencies and may allow further simplifications.Enabled by default at-O1 and higher.
-fivopts ¶Perform induction variable optimizations (strength reduction, inductionvariable merging and induction variable elimination) on trees.Enabled by default at-O1 and higher.
-ftree-parallelize-loops ¶-ftree-parallelize-loops=nParallelize loops, i.e., split their iteration space to run in multiple threads.This is only possible for loops whose iterations are independentand can be arbitrarily reordered. The optimization is onlyprofitable on multiprocessor machines, for loops that are CPU-intensive,rather than constrained e.g. by memory bandwidth. This optionimplies-pthread, and thus is only supported on targetsthat have support for-pthread.
When a positive valuen is specified, the number of threads is fixedat compile time and cannot be changed after compilation. The compilergenerates “#pragma omp parallel num_threads(n)”.
When used without=n (i.e.,-ftree-parallelize-loops),the number of threads is determined at program execution time via theOMP_NUM_THREADS environment variable. IfOMP_NUM_THREADS is notset, the OpenMP runtime automatically detects the number of availableprocessors and uses that value. This enables creating binaries thatadapt to different hardware configurations without recompilation.
-ftree-pta ¶Perform function-local points-to analysis on trees. This flag isenabled by default at-O1 and higher, except for-Og.
-ftree-sra ¶Perform scalar replacement of aggregates. This pass replaces structurereferences with scalars to prevent committing structures to memory tooearly. This flag is enabled by default at-O1 and higher,except for-Og.
-fstore-merging ¶Perform merging of narrow stores to consecutive memory addresses. This passmerges contiguous stores of immediate values narrower than a word into fewerwider stores to reduce the number of instructions. This is enabled by defaultat-O2 and higher as well as-Os.
-ftree-ter ¶Perform temporary expression replacement during the SSA->normal phase. Singleuse/single def temporaries are replaced at their use location with theirdefining expression. This results in non-GIMPLE code, but gives the expandersmuch more complex trees to work on resulting in better RTL generation. This isenabled by default at-O1 and higher.
-ftree-slsr ¶Perform straight-line strength reduction on trees. This recognizes relatedexpressions involving multiplications and replaces them by less expensivecalculations when possible. This is enabled by default at-O1 andhigher.
-ftree-vectorize ¶Perform vectorization on trees. This flag enables-ftree-loop-vectorizeand-ftree-slp-vectorize if not explicitly specified.
-ftree-loop-vectorize ¶Perform loop vectorization on trees. This flag is enabled by default at-O2 and by-ftree-vectorize,-fprofile-use,and-fauto-profile.
-ftree-slp-vectorize ¶Perform basic block vectorization on trees. This flag is enabled by default at-O2 and by-ftree-vectorize,-fprofile-use,and-fauto-profile.
-ftrivial-auto-var-init=choice ¶Initialize automatic variables or temporary objects with either a pattern or withzeroes to increase the security and predictability of a program by preventinguninitialized memory disclosure and use.GCC still considers an automatic variable that doesn’t have an explicitinitializer as uninitialized,-Wuninitialized and-Wanalyzer-use-of-uninitialized-value will still reportwarning messages on such automatic variables or temporary objects and thecompiler will perform optimization as if the variable were uninitialized.With this option, GCC will also initialize any padding of automatic variablesor temporary objects that have structure or union types to zeroes.However, the current implementation cannot initialize automatic variableswhose initialization is bypassed throughswitch orgotostatement. Using-Wtrivial-auto-var-init to report all such cases.
The three values ofchoice are:
The default is ‘uninitialized’ except for C++26, in which caseif-ftrivial-auto-var-init= is not specified at all automaticvariables or temporary objects are zero initialized, but zero initializationof padding bits does not happen.
Note that the initializer values, whether ‘zero’ or ‘pattern’,refer to data representation (in memory or machine registers), ratherthan to their interpretation as numerical values. This distinction maybe important in languages that support types with biases or implicitmultipliers, and with such extensions as ‘hardbool’ (seeSpecifying Attributes of Types). For example, a variable that uses 8 bits to represent(biased) quantities in therange 160..400 will be initializedwith the bit patterns0x00 or0xFE, depending onchoice, whether or not these representations stand for values inthat range, and even if they do, the interpretation of the value held bythe variable will depend on the bias. A ‘hardbool’ variable thatuses say0x5A and0xA5 forfalse andtrue,respectively, will trap with either ‘choice’ of trivialinitializer, i.e., ‘zero’ initialization will not convert to therepresentation forfalse, even if it would for astaticvariable of the same type. This means the initializer pattern doesn’tgenerally depend on the type of the initialized variable. One notableexception is that (non-hardened) boolean variables that fit in registersare initialized withfalse (zero), even when ‘pattern’ isrequested.
You can control this behavior for a specific variable by using the variableattributeuninitialized standard attribute (seeSpecifying Attributes of Variables)or the C++26[[indeterminate]].
-fvect-cost-model=model ¶Alter the cost model used for vectorization. Themodel argumentshould be one of ‘unlimited’, ‘dynamic’, ‘cheap’ or‘very-cheap’.With the ‘unlimited’ model the vectorized code-path is assumedto be profitable while with the ‘dynamic’ model a runtime checkguards the vectorized code-path to enable it only for iterationcounts that will likely execute faster than when executing the originalscalar loop. The ‘cheap’ model disables vectorization ofloops where doing so would be cost prohibitive for example due torequired runtime checks for data dependence or alignment but otherwiseis equal to the ‘dynamic’ model. The ‘very-cheap’ model disablesvectorization of loops when any runtime check for data dependence or alignmentis required, it also disables vectorization of epilogue loops but otherwise isequal to the ‘cheap’ model.
The default cost model depends on other optimization flags and iseither ‘dynamic’ or ‘cheap’.
-fsimd-cost-model=model ¶Alter the cost model used for vectorization of loops marked with the OpenMPsimd directive. Themodel argument should be one of‘unlimited’, ‘dynamic’, ‘cheap’. All values ofmodelhave the same meaning as described in-fvect-cost-model and bydefault a cost model defined with-fvect-cost-model is used.
-ftree-vrp ¶Perform Value Range Propagation on trees. This is similar to theconstant propagation pass, but instead of values, ranges of values arepropagated. This allows the optimizers to remove unnecessary rangechecks like array bound checks and null pointer checks. This isenabled by default at-O2 and higher. Null pointer checkelimination is only done if-fdelete-null-pointer-checks isenabled.
-fsplit-paths ¶Split paths leading to loop backedges. This can improve dead codeelimination and common subexpression elimination. This is enabled bydefault at-O3 and above.
-fsplit-ivs-in-unroller ¶Enables expression of values of induction variables in later iterationsof the unrolled loop using the value in the first iteration. This breakslong dependency chains, thus improving efficiency of the scheduling passes.
A combination of-fweb and CSE is often sufficient to obtain thesame effect. However, that is not reliable in cases where the loop bodyis more complicated than a single basic block. It also does not work at allon some architectures due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller ¶With this option, the compiler creates multiple copies of somelocal variables when unrolling a loop, which can result in superior code.
This optimization is enabled by default for PowerPC targets, but disabledby default otherwise.
-fpartial-inlining ¶Inline parts of functions. This option has any effect onlywhen inlining itself is turned on by the-finline-functionsor-finline-small-functions options.
Enabled at levels-O2,-O3,-Os.
-fpredictive-commoning ¶Perform predictive commoning optimization, i.e., reusing computations(especially memory loads and stores) performed in previousiterations of loops.
This option is enabled at level-O3.It is also enabled by-fprofile-use and-fauto-profile.
-fprefetch-loop-arrays ¶If supported by the target machine, generate instructions to prefetchmemory to improve the performance of loops that access large arrays.
This option may generate better or worse code; results are highlydependent on the structure of loops within the source code.
Disabled at level-Os.
-fno-printf-return-value ¶Do not substitute constants for known return value of formatted outputfunctions such assprintf,snprintf,vsprintf, andvsnprintf (but notprintf offprintf). Thistransformation allows GCC to optimize or even eliminate branches basedon the known return value of these functions called with arguments thatare either constant, or whose values are known to be in a range thatmakes determining the exact return value possible. For example, when-fprintf-return-value is in effect, both the branch and thebody of theif statement (but not the call tosnprint)can be optimized away wheni is a 32-bit or smaller integerbecause the return value is guaranteed to be at most 8.
char buf[9];if (snprintf (buf, "%08x", i) >= sizeof buf) …
The-fprintf-return-value option relies on other optimizationsand yields best results with-O2 and above. It works in tandemwith the-Wformat-overflow and-Wformat-truncationoptions. The-fprintf-return-value option is enabled by default.
-fno-peephole ¶-fno-peephole2Disable any machine-specific peephole optimizations. The differencebetween-fno-peephole and-fno-peephole2 is in how theyare implemented in the compiler; some targets use one, some use theother, a few use both.
-fpeephole is enabled by default.-fpeephole2 enabled at levels-O2,-O3,-Os.
-fno-guess-branch-probability ¶Do not guess branch probabilities using heuristics.
GCC uses heuristics to guess branch probabilities if they arenot provided by profiling feedback (-fprofile-arcs). Theseheuristics are based on the control flow graph. If some branch probabilitiesare specified by__builtin_expect, then the heuristics areused to guess branch probabilities for the rest of the control flow graph,taking the__builtin_expect info into account. The interactionsbetween the heuristics and__builtin_expect can be complex, and insome cases, it may be useful to disable the heuristics so that the effectsof__builtin_expect are easier to understand.
It is also possible to specify expected probability of the expressionwith__builtin_expect_with_probability built-in function.
The default is-fguess-branch-probability at levels-O,-O2,-O3,-Os.
-freorder-blocks ¶Reorder basic blocks in the compiled function in order to reduce number oftaken branches and improve code locality.
Enabled at levels-O1,-O2,-O3,-Os.
-freorder-blocks-algorithm=algorithm ¶Use the specified algorithm for basic block reordering. Thealgorithm argument can be ‘simple’, which does not increasecode size (except sometimes due to secondary effects like alignment),or ‘stc’, the “software trace cache” algorithm, which tries toput all often executed code together, minimizing the number of branchesexecuted by making extra copies of code.
The default is ‘simple’ at levels-O1,-Os, and‘stc’ at levels-O2,-O3.
-freorder-blocks-and-partition ¶In addition to reordering basic blocks in the compiled function, in orderto reduce number of taken branches, partitions hot and cold basic blocksinto separate sections of the assembly and.o files, to improvepaging and cache locality performance.
This optimization is automatically turned off in the presence ofexception handling or unwind tables (on targets using setjump/longjump or target specific scheme), for linkonce sections, for functions with a user-definedsection attribute and on any architecture that does not support namedsections. When-fsplit-stack is used this option is notenabled by default (to avoid linker errors), but may be enabledexplicitly (if using a working linker).
Enabled for x86 at levels-O2,-O3,-Os.
-freorder-functions ¶Reorder functions in the object file in order toimprove code locality. Unlike-fipa-reorder-for-locality this optionprioritises grouping all functions within a category(hot/normal/cold/never-executed) together.This is implemented by using special subsections.text.hot for mostfrequently executed functions and.text.unlikely for unlikely executedfunctions. Reordering is done by the linker so object file format must supportnamed sections and linker must place them in a reasonable way.
This option isn’t effective unless you either provide profile feedback(see-fprofile-arcs for details) or manually annotate functions withhot orcold attributes (seeCommon Function Attributes).
Enabled at levels-O2,-O3,-Os.
-fstrict-aliasing ¶Allow the compiler to assume the strictest aliasing rules applicable tothe language being compiled. For C (and C++), this activatesoptimizations based on the type of expressions. In particular, accessingan object of one type via an expression of a different type is not allowed,unless the types arecompatible types, differ only in signedness orqualifiers, or the expression has a character type. Accessing scalarobjects via a corresponding vector type is also allowed.
For example, anunsigned int can alias anint, but not avoid* or adouble. 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 mostrecently written to (called “type-punning”) is common. Even with-fstrict-aliasing, type-punning is allowed in C, provided the memoryis accessed through the union type. In ISO C++, type-punning through a uniontype is undefined behavior, but GCC supports it as an extension. So, the codeabove works as expected. SeeStructures, Unions, Enumerations, and Bit-Fields. 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 pointerand dereferencing the result has undefined behavior, even if the castuses 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.
-fipa-strict-aliasing ¶Controls whether rules of-fstrict-aliasing are applied acrossfunction boundaries. Note that if multiple functions gets inlined into asingle function the memory accesses are no longer considered to be crossing afunction boundary.
The-fipa-strict-aliasing option is enabled by default and iseffective only in combination with-fstrict-aliasing.
-falign-functions ¶-falign-functions=n-falign-functions=n:m-falign-functions=n:m:n2-falign-functions=n:m:n2:m2Align the start of functions to the next power-of-two greater than orequal ton, skipping up tom-1 bytes. This ensures that atleast the firstm bytes of the function can be fetched by the CPUwithout crossing ann-byte alignment boundary.This is an optimization of code performance and alignment is ignored forfunctions considered cold. If alignment is required for all functions,use-fmin-function-alignment.
Ifm is not specified, it defaults ton.
Examples:-falign-functions=32 aligns functions to the next32-byte boundary,-falign-functions=24 aligns to the next32-byte boundary only if this can be done by skipping 23 bytes or less,-falign-functions=32:7 aligns to the next32-byte boundary only if this can be done by skipping 6 bytes or less.
The second pair ofn2:m2 values allows you to specifya secondary alignment:-falign-functions=64:7:32:3 aligns tothe next 64-byte boundary if this can be done by skipping 6 bytes or less,otherwise aligns to the next 32-byte boundary if this can be doneby skipping 2 bytes or less.Ifm2 is not specified, it defaults ton2.
Some assemblers only support this flag whenn is a power of two;in that case, it is rounded up.
-fno-align-functions and-falign-functions=1 areequivalent and mean that functions are not aligned.
Ifn is not specified or is zero, use a machine-dependent default.The maximum allowedn option value is 65536.
Enabled at levels-O2,-O3.
-flimit-function-alignment ¶If this option is enabled, the compiler tries to avoid unnecessarilyoveraligning functions. It attempts to instruct the assembler to alignby the amount specified by-falign-functions, but not toskip more bytes than the size of the function.
-falign-labels ¶-falign-labels=n-falign-labels=n:m-falign-labels=n:m:n2-falign-labels=n:m:n2:m2Align all branch targets to a power-of-two boundary.
Parameters of this option are analogous to the-falign-functions option.-fno-align-labels and-falign-labels=1 areequivalent and mean that labels are not aligned.
If-falign-loops or-falign-jumps are applicable andare greater than this value, then their values are used instead.
Ifn is not specified or is zero, use a machine-dependent defaultwhich is very likely to be ‘1’, meaning no alignment.The maximum allowedn option value is 65536.
Enabled at levels-O2,-O3.
-falign-loops ¶-falign-loops=n-falign-loops=n:m-falign-loops=n:m:n2-falign-loops=n:m:n2:m2Align loops to a power-of-two boundary. If the loops are executedmany times, this makes up for any execution of the dummy paddinginstructions.This is an optimization of code performance and alignment is ignored forloops considered cold.
If-falign-labels is greater than this value, then its valueis used instead.
Parameters of this option are analogous to the-falign-functions option.-fno-align-loops and-falign-loops=1 areequivalent and mean that loops are not aligned.The maximum allowedn option value is 65536.
Ifn is not specified or is zero, use a machine-dependent default.
Enabled at levels-O2,-O3.
-falign-jumps ¶-falign-jumps=n-falign-jumps=n:m-falign-jumps=n:m:n2-falign-jumps=n:m:n2:m2Align branch targets to a power-of-two boundary, for branch targetswhere the targets can only be reached by jumping. In this case,no dummy operations need be executed.This is an optimization of code performance and alignment is ignored forjumps considered cold.
If-falign-labels is greater than this value, then its valueis used instead.
Parameters of this option are analogous to the-falign-functions option.-fno-align-jumps and-falign-jumps=1 areequivalent and mean that loops are not aligned.
Ifn is not specified or is zero, use a machine-dependent default.The maximum allowedn option value is 65536.
Enabled at levels-O2,-O3.
-fmin-function-alignment ¶Specify minimal alignment of functions to the next power-of-two greater than orequal ton. Unlike-falign-functions this alignment is appliedalso to all functions (even those considered cold). The alignment is also notaffected by-flimit-function-alignment
-fno-allocation-dce ¶Do not remove unused C++ allocations (using operatornew and operatordelete)in dead code elimination.
See also-fmalloc-dce.
-fallow-store-data-races ¶Allow the compiler to perform optimizations that may introduce new data raceson stores, without proving that the variable cannot be concurrently accessedby other threads. Does not affect optimization of local data. It is safe touse this option if it is known that global data will not be accessed bymultiple threads.
Examples of optimizations enabled by-fallow-store-data-races includehoisting or if-conversions that may cause a value that was already in memoryto be re-written with that same value. Such re-writing is safe in a singlethreaded context but may be unsafe in a multi-threaded context. Note that onsome processors, if-conversions may be required in order to enablevectorization.
Enabled at level-Ofast.
-funit-at-a-time ¶This option is left for compatibility reasons.-funit-at-a-timehas no effect, while-fno-unit-at-a-time implies-fno-toplevel-reorder and-fno-section-anchors.
Enabled by default.
-fno-toplevel-reorder ¶Do not reorder top-level functions, variables, andasmstatements. Output them in the same order that they appear in theinput file. When this option is used, unreferenced static variablesare not removed. This option is intended to support existing codethat relies on a particular ordering. For new code, it is better touse attributes when possible.
-ftoplevel-reorder is the default at-O1 and higher, andalso at-O0 if-fsection-anchors is explicitly requested.Additionally-fno-toplevel-reorder implies-fno-section-anchors.
-funreachable-traps ¶With this option, the compiler turns calls to__builtin_unreachable into traps, instead of using them foroptimization. This also affects any such calls implicitly generatedby the compiler.
This option has the same effect as-fsanitize=unreachable-fsanitize-trap=unreachable, but does not affect the values of thoseoptions. If-fsanitize=unreachable is enabled, that optiontakes priority over this one.
This option is enabled by default at-O0 and-Og.
-fweb ¶Constructs webs as commonly used for register allocation purposes and assigneach web individual pseudo register. This allows the register allocation passto operate on pseudos directly, but also strengthens several other optimizationpasses, such as CSE, loop optimizer and trivial dead code remover. It can,however, make debugging impossible, since variables no longer stay in a“home register”.
Enabled by default with-funroll-loops.
-fwhole-program ¶Assume that the current compilation unit represents the whole program beingcompiled. All public functions and variables with the exception ofmainand those merged by attributeexternally_visible become static functionsand in effect are optimized more aggressively by interprocedural optimizers.
With-flto this option has a limited use. In most cases theprecise list of symbols used or exported from the binary is known theresolution info passed to the link-time optimizer by the linker plugin. It isstill useful if no linker plugin is used or during incremental link step whenfinal code is produced (with-flto-flinker-output=nolto-rel).
-flto[=n] ¶This option runs the standard link-time optimizer. When invokedwith source code, it generates GIMPLE (one of GCC’s internalrepresentations) and writes it to special ELF sections in the objectfile. When the object files are linked together, all the functionbodies are read from these ELF sections and instantiated as if theyhad been part of the same translation unit.
To use the link-time optimizer,-flto and optimizationoptions should be specified at compile time and during the final link.It is recommended that you compile all the files participating in thesame link with the same options and also specify those options atlink time.For example:
gcc -c -O2 -flto foo.cgcc -c -O2 -flto bar.cgcc -o myprog -flto -O2 foo.o bar.o
The first two invocations to GCC save a bytecode representationof GIMPLE into special ELF sections insidefoo.o andbar.o. The final invocation reads the GIMPLE bytecode fromfoo.o andbar.o, merges the two files into a singleinternal image, and compiles the result as usual. Since bothfoo.o andbar.o are merged into a single image, thiscauses all the interprocedural analyses and optimizations in GCC towork across the two files as if they were a single one. This means,for example, that the inliner is able to inline functions inbar.o into functions infoo.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 forfoo.c andbar.c,merges them together into a single GIMPLE representation and optimizesthem as usual to producemyprog.
The important thing to keep in mind is that to enable link-timeoptimizations you need to use the GCC driver to perform the link step.GCC automatically performs link-time optimization if any of theobjects involved were compiled with the-flto command-line option.You can always overridethe automatic decision to do link-time optimizationby passing-fno-lto to the link command.
To make whole-program optimization effective, it is necessary to makecertain assumptions. The compiler needs to knowwhat functions and variables can be accessed by libraries and runtimeoutside of the link-time optimized unit. When supported by the linker,the linker plugin (see-fuse-linker-plugin) passes informationto the compiler about used and externally visible symbols. Whenthe linker plugin is not available,-fwhole-program should beused to allow the compiler to make these assumptions, which leadsto more aggressive optimization decisions.
When a file is compiled with-flto without-fuse-linker-plugin, the generated object file is larger thana regular object file because it contains GIMPLE bytecodes and the usualfinal code (see-ffat-lto-objects). This means thatobject files with LTO information can be linked as normal objectfiles; if-fno-lto is passed to the linker, nointerprocedural optimizations are applied. Note that when-fno-fat-lto-objects is enabled the compile stage is fasterbut you cannot perform a regular, non-LTO link on them.
When producing the final binary, GCC onlyapplies link-time optimizations to those files that contain bytecode.Therefore, you can mix and match object files and libraries withGIMPLE bytecodes and final object code. GCC automatically selectswhich files to optimize in LTO mode and which files to link withoutfurther processing.
Generally, options specified at link time override thosespecified at compile time, although in some cases GCC attempts to inferlink-time options from the settings used to compile the input files.
If you do not specify an optimization level option-O atlink time, then GCC uses the highest optimization levelused when compiling the object files. Note that it is generallyineffective to specify an optimization level option only at link time andnot at compile time, for two reasons. First, compiling withoutoptimization suppresses compiler passes that gather informationneeded for effective optimization at link time. Second, some earlyoptimization passes can be performed only at compile time andnot at link time.
There are some code generation flags preserved by GCC whengenerating bytecodes, as they need to be used during the final link.Currently, the following options and their settings are taken fromthe first object file that explicitly specifies them:-fcommon,-fexceptions,-fnon-call-exceptions,-fgnu-tm and all the-m target flags.
The following options-fPIC,-fpic,-fpie and-fPIE are combined based on the following scheme:
-fPIC +-fpic =-fpic-fPIC +-fno-pic =-fno-pic-fpic/-fPIC + (no option) = (no option)-fPIC +-fPIE =-fPIE-fpic +-fPIE =-fpie-fPIC/-fpic +-fpie =-fpie
Certain ABI-changing flags are required to match in all compilation units,and trying to override this at link time with a conflicting valueis ignored. This includes options such as-freg-struct-returnand-fpcc-struct-return.
Other options such as-ffp-contract,-fno-strict-overflow,-fwrapv,-fno-trapv or-fno-strict-aliasingare passed through to the link stage and merged conservatively forconflicting translation units. Specifically-fno-strict-overflow,-fwrapv and-fno-trapv takeprecedence; and for example-ffp-contract=off takes precedenceover-ffp-contract=fast. You can override them at link time.
Diagnostic options such as-Wstringop-overflow are passedthrough to the link stage and their setting matches that of thecompile-step at function granularity. Note that this matters onlyfor diagnostics emitted during optimization. Note that codetransforms such as inlining can lead to warnings being enabledor disabled for regions if code not consistent with the settingat compile time.
When you need to pass options to the assembler via-Wa or-Xassembler make sure to either compile such translationunits with-fno-lto or consistently use the same assembleroptions on all translation units. You can alternatively alsospecify assembler options at LTO link time.
To enable debug info generation you need to supply-g atcompile time. If any of the input files at link time were builtwith debug info generation enabled the link will enable debug infogeneration as well. Any elaborate debug info settingslike the dwarf level-gdwarf-5 need to be explicitly repeatedat the linker command line and mixing different settings in differenttranslation units is discouraged.
If LTO encounters objects with C linkage declared with incompatibletypes in separate translation units to be linked together (undefinedbehavior according to ISO C99 6.2.7), a non-fatal diagnostic may beissued. The behavior is still undefined at run time. Similardiagnostics may be raised for other languages.
Another feature of LTO is that it is possible to apply interproceduraloptimizations on files written in different languages:
gcc -c -flto foo.cg++ -c -flto bar.ccgfortran -c -flto baz.f90g++ -o myprog -flto -O3 foo.o bar.o baz.o -lgfortran
Notice that the final link is done withg++ to get the C++runtime libraries and-lgfortran is added to get the Fortranruntime libraries. In general, when mixing languages in LTO mode, youshould use the same link command options as when mixing languages in aregular (non-LTO) compilation.
If object files containing GIMPLE bytecode are stored in a library archive, saylibfoo.a, it is possible to extract and use them in an LTO link if youare using a linker with plugin support. To create static libraries suitablefor LTO, usegcc-ar andgcc-ranlib instead ofarandranlib;to show the symbols of object files with GIMPLE bytecode, usegcc-nm. Those commands require thatar,ranlibandnm have been compiled with plugin support. At link time, use theflag-fuse-linker-plugin to ensure that the library participates inthe 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 neededGIMPLE files fromlibfoo.a and passes them on to the running GCCto make them part of the aggregated GIMPLE image to be optimized.
If you are not using a linker with plugin support and/or do notenable the linker plugin, then the objects insidelibfoo.aare extracted and linked as usual, but they do not participatein the LTO optimization process. In order to make a static library suitablefor 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 tooperate. If the program does not require any symbols to be exported, it ispossible to combine-flto and-fwhole-program to allowthe interprocedural optimizers to use more aggressive assumptions which maylead to improved optimization opportunities.Use of-fwhole-program is not needed when linker plugin isactive (see-fuse-linker-plugin).
The current implementation of LTO makes noattempt to generate bytecode that is portable between differenttypes of hosts. The bytecode files are versioned and there is astrict version check, so bytecode files generated in one version ofGCC do not work with an older or newer version of GCC.
Link-time optimization does not work well with generation of debugginginformation on systems other than those using a combination of ELF andDWARF.
If you specify the optionaln, the optimization and codegeneration done at link time is executed in parallel usingnparallel jobs by utilizing an installedmake program. Theenvironment variableMAKE may be used to override the programused.
You can also specify-flto=jobserver to use GNU make’sjob server mode to determine the number of parallel jobs. Thisis useful when the Makefile calling GCC is already executing in parallel.You must prepend a ‘+’ to the command recipe in the parent Makefilefor this to work. This option likely only works ifMAKE isGNU make. Even without the option value, GCC tries to automaticallydetect a running GNU make’s job server.
Use-flto=auto to use GNU make’s job server, if available,or otherwise fall back to autodetection of the number of CPU threadspresent in your system.
-flto-partition=alg ¶Specify the partitioning algorithm used by the link-time optimizer.The value is either ‘1to1’ to specify a partitioning mirroringthe original source files or ‘balanced’ to specify partitioninginto equally sized chunks (whenever possible) or ‘max’ to createnew partition for every symbol where possible or ‘cache’ tobalance chunk sizes while keeping related symbols together for bettercaching in incremental LTO. Specifying ‘none’ as an algorithmdisables partitioning and streaming completely.The default value is ‘balanced’. While ‘1to1’ can be usedas an workaround for various code ordering issues, the ‘max’partitioning is intended for internal testing only.The value ‘one’ specifies that exactly one partition should beused while the value ‘none’ bypasses partitioning and executesthe link-time optimization step directly from the WPA phase.
-flto-incremental=path ¶Enable incremental LTO, with its cache in given existing directory.Can significantly shorten edit-compile cycles with LTO.
When used with LTO (-flto), the output of translation unitsinside LTO is cached. Cached translation units are likely to beencountered again when recompiling with small code changes, leading torecompile time reduction.
Multiple GCC instances can use the same cache in parallel.
-flto-incremental-cache-size=n ¶Specifies number of cache entries in incremental LTO after which to pruneold entries. This is a soft limit, temporarily there may be more entries.
-flto-compression-level=n ¶This option specifies the level of compression used for intermediatelanguage written to LTO object files, and is only meaningful inconjunction with LTO mode (-flto). GCC currently supports twoLTO compression algorithms. For zstd, valid values are 0 (no compression)to 19 (maximum compression), while zlib supports values from 0 to 9.Values outside this range are clamped to either minimum or maximumof the supported values. If the option is not given,a default balanced compression setting is used.
-flto-toplevel-asm-heuristics ¶Enables heuristics to find symbols used in top-level basicasm.This will restrict link-time optimizations that could cause renamingor deletion of such symbols which would result in missing symbol errors bylinker.
This flag is intended for projects that have not converted to using top-levelextendedasm (seeExtended Asm - Assembler Instructions with C Expression Operands), which specify the usage directlywithout any false positives.
The heuristics are simple and do not parse the assembly.The heuristics scan through top-level assembly for all possible identifiers;if an identifier is found among declared symbols, the symbol will be marked torestrict link-time optimizations. Static symbols disable more optimizations.Identifiers followed by ’:’ disable more optimizations as well, because theymight be a locally defined symbol in assembly, even when the declarationis marked ’extern’.
-fuse-linker-plugin ¶Enables the use of a linker plugin during link-time optimization. Thisoption relies on plugin support in the linker, which is available in goldor in GNU ld 2.21 or newer.
This option enables the extraction of object files with GIMPLE bytecode outof library archives. This improves the quality of optimization by exposingmore code to the link-time optimizer. This information specifies whatsymbols can be accessed externally (by non-LTO object or during dynamiclinking). Resulting code quality improvements on binaries (and sharedlibraries that use hidden visibility) are similar to-fwhole-program.See-flto for a description of the effect of this flag and how touse it.
This option is enabled by default when LTO support in GCC is enabledand GCC was configured for use witha linker supporting plugins (GNU ld 2.21 or newer or gold).
-ffat-lto-objects ¶Fat LTO objects are object files that contain both the intermediate languageand the object code. This makes them usable for both LTO linking and normallinking. This option is effective only when compiling with-fltoand is ignored at link time.
-fno-fat-lto-objects improves compilation time over plain LTO, butrequires the complete toolchain to be aware of LTO. It requires a linker withlinker plugin support for basic functionality. Additionally,nm,ar andranlibneed to support linker plugins to allow a full-featured build environment(capable of building static libraries etc). GCC provides thegcc-ar,gcc-nm,gcc-ranlib wrappers to pass the right optionsto these tools. With non fat LTO makefiles need to be modified to use them.
Note that modern binutils provide plugin auto-load mechanism.Installing the linker plugin into$libdir/bfd-plugins has the sameeffect as usage of the command wrappers (gcc-ar,gcc-nm andgcc-ranlib).
The default is-fno-fat-lto-objects on targets with linker pluginsupport.
-fcompare-elim ¶After register allocation and post-register allocation instruction splitting,identify arithmetic instructions that compute processor flags similar to acomparison operation based on that arithmetic. If possible, eliminate theexplicit comparison operation.
This pass only applies to certain targets that cannot explicitly representthe comparison operation before register allocation is complete.
Enabled at levels-O1,-O2,-O3,-Os.
-ffold-mem-offsets ¶-fno-fold-mem-offsetsTry to eliminate add instructions by folding them in memory loads/stores.
Enabled at levels-O2,-O3.
-fcprop-registers ¶After register allocation and post-register allocation instruction splitting,perform a copy-propagation pass to try to reduce scheduling dependenciesand occasionally eliminate the copy.
Enabled at levels-O1,-O2,-O3,-Os.
-fprofile-correction ¶Profiles collected using an instrumented binary for multi-threaded programs maybe inconsistent due to missed counter updates. When this option is specified,GCC uses heuristics to correct or smooth out such inconsistencies. Bydefault, GCC emits an error message when an inconsistent profile is detected.
This option is enabled by-fauto-profile.
-fprofile-partial-training ¶With-fprofile-use all portions of programs not executed duringtraining runs are optimized aggressively for size rather than speed.In some cases it is not practical to train all possible hot paths inthe program. (For example, it may contain functions specific to agiven hardware and training may not cover all hardware configurationsthe program later runs on.) With-fprofile-partial-trainingprofile feedback is ignored for all functions not executed during thetraining runs, causing them to be optimized as if they were compiledwithout profile feedback. This leads to better performance when thetraining is not representative at the cost of significantly bigger code.
-fprofile-use ¶-fprofile-use=pathEnable profile feedback-directed optimizations,and the following optimizations, many of whichare generally profitable only with profile feedback available:
-fbranch-probabilities -fprofile-values-funroll-loops -fpeel-loops -ftracer -fvpt-finline-functions -fipa-cp -fipa-cp-clone -fipa-bit-cp-fpredictive-commoning -fsplit-loops -funswitch-loops-fgcse-after-reload -ftree-loop-vectorize -ftree-slp-vectorize-fvect-cost-model=dynamic -ftree-loop-distribute-patterns-fprofile-reorder-functions
Before you can use this option, you must first generate profiling information.SeeProgram Instrumentation Options, for information about the-fprofile-generate option.
By default, GCC emits an error message if the feedback profiles do notmatch the source code. This error can be turned into a warning by using-Wno-error=coverage-mismatch. Note this may result in poorlyoptimized code. Additionally, by default, GCC also emits a warning message ifthe feedback profiles do not exist (see-Wmissing-profile).
Ifpath is specified, GCC looks at thepath to findthe profile feedback data files. See-fprofile-dir.
-fauto-profile ¶-fauto-profile=pathEnable sampling-based feedback-directed optimizations,and the following optimizations,many of which are generally profitable only with profile feedback available:
-fbranch-probabilities -fprofile-values-funroll-loops -fpeel-loops -ftracer -fvpt-finline-functions -fipa-cp -fipa-cp-clone -fipa-bit-cp-fpredictive-commoning -fsplit-loops -funswitch-loops-fgcse-after-reload -ftree-loop-vectorize -ftree-slp-vectorize-fvect-cost-model=dynamic -ftree-loop-distribute-patterns-fprofile-correction
path is the name of a file containing AutoFDO profile information.If omitted, it defaults tofbdata.afdo in the current directory.
Producing an AutoFDO profile data file requires running your programwith theperf utility on a supported GNU/Linux target system.For more information, seehttps://perfwiki.github.io/main/.
E.g.
perf record -e br_inst_retired:near_taken -b -o perf.data \ -- your_program
Then use thecreate_gcov tool to convert the raw profile datato a format that can be used by GCC. You must also supply theunstripped binary for your program to this tool.Seehttps://github.com/google/autofdo.
E.g.
create_gcov --binary=your_program.unstripped --profile=perf.data \ --gcov=profile.afdo
-fauto-profile-inlining ¶When auto-profile is available inline all relevant functions which wasinlined in the tran run before reading the profile feedback. This improvescontext sensitivity of the profile. Enabled by default.
The following options control compiler behavior regarding floating-pointarithmetic. These options trade off between speed andcorrectness. All must be specifically enabled.
-fexcess-precision=style ¶This option allows control over excess precision on machineswhere floating-point operations occur in a format with more precision orrange than the IEEE standard and interchange floating-point types.An example of such a target is x87 floating point on x86 processors,which uses an 80-bit representation internally instead of the 64-bitIEEE format. For most programs, the excess precision is harmless,but some programs may rely on therequirements of the C or C++ language standards for handling IEEE values.
By default,-fexcess-precision=fast is in effect; this means thatoperations may be carried out in a wider precision than the types specifiedin the source if that would result in faster code, and it is unpredictablewhen rounding to the types specified in the source code takes place.When compiling C or C++, if-fexcess-precision=standard is specifiedthen excess precision follows the rules specified in ISO C99 or C++;in particular,both casts and assignments cause values to be rounded to theirsemantic types (whereas-ffloat-store only affectsassignments). This option is enabled by default for C or C++ if a strictconformance option such as-std=c99 or-std=c++17 is used.-ffast-math enables-fexcess-precision=fast by defaultregardless of whether a strict conformance option is used.If-fexcess-precision=16 is specified, constants and theresults of expressions with types_Float16 and__bf16are computed without excess precision.
-fexcess-precision=standard is not implemented for languagesother than C or C++. On the x86, it has no effect if-mfpmath=sseor-mfpmath=sse+387 is specified; in the former case, IEEEsemantics apply without excess precision, and in the latter, roundingis unpredictable.
-ffloat-store ¶Do not store floating-point variables in registers, and inhibit otheroptions that might change whether a floating-point value is taken from aregister or memory. This option has generally been subsumed by-fexcess-precision=standard, which is more general. If you do use-ffloat-store, you may need to modify your program to explicitlystore intermediate computations in temporary variables since-ffloat-store handles rounding to IEEE formatonly on assignments and not casts as-fexcess-precision=standarddoes.
-ffast-math ¶Sets the options-fno-math-errno,-funsafe-math-optimizations,-ffinite-math-only,-fno-rounding-math,-fno-signaling-nans,-fcx-limited-range and-fexcess-precision=fast.
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 programsthat depend on an exact implementation of IEEE or ISO rules/specificationsfor math functions. It may, however, yield faster code for programsthat do not require the guarantees of these specifications.
-fno-math-errno ¶Do not seterrno after calling math functions that are executedwith a single instruction, e.g.,sqrt. A program that relies onIEEE exceptions for math error handling may want to use this flagfor speed while maintaining IEEE arithmetic compatibility.
This option is not turned on by any-O option besides-Ofast since it can result in incorrect output forprograms that depend on an exact implementation of IEEE orISO rules/specifications for math functions. It may, however,yield faster code for programs that do not require the guaranteesof these specifications.
The default is-fmath-errno.
On Darwin systems, the math library never setserrno. There istherefore no reason for the compiler to consider the possibility thatit might, and-fno-math-errno is the default.
-funsafe-math-optimizations ¶Allow optimizations for floating-point arithmetic that (a) assumethat arguments and results are valid and (b) may violate IEEE orANSI standards. When used at link time, it may include librariesor startup files that change the default FPU control word or othersimilar optimizations.
This option is not turned on by any-O option besides-Ofast since it can result in incorrect outputfor programs that depend on an exact implementation of IEEEor ISO rules/specifications for math functions. It may, however,yield faster code for programs that do not require the guaranteesof these specifications.Enables-fno-signed-zeros,-fno-trapping-math,-fassociative-math and-freciprocal-math.
The default is-fno-unsafe-math-optimizations.
-fassociative-math ¶Allow re-association of operands in series of floating-point operations.This violates the ISO C and C++ language standard by possibly changingcomputation result. NOTE: re-ordering may change the sign of zero aswell as ignore NaNs and inhibit or create underflow or overflow (andthus cannot be used on code that relies on rounding behavior like(x + 2**52) - 2**52. May also reorder floating-point comparisonsand 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 makemuch sense with-frounding-math. For Fortran the optionis automatically enabled when both-fno-signed-zeros and-fno-trapping-math are in effect.
The default is-fno-associative-math.
-freciprocal-math ¶Allow the reciprocal of a value to be used instead of dividing bythe value if this enables optimizations. For examplex / ycan be replaced withx * (1/y), which is useful if(1/y)is subject to common subexpression elimination. Note that this losesprecision and increases the number of flops operating on the value.
The default is-fno-reciprocal-math.
-ffinite-math-only ¶Allow optimizations for floating-point arithmetic that assumethat arguments and results are not NaNs or +-Infs.
This option is not turned on by any-O option besides-Ofast since it can result in incorrect outputfor programs that depend on an exact implementation of IEEE orISO rules/specifications for math functions. It may, however,yield faster code for programs that do not require the guaranteesof these specifications.
The default is-fno-finite-math-only.
-fno-signed-zeros ¶Allow optimizations for floating-point arithmetic that ignore thesignedness of zero. IEEE arithmetic specifies the behavior ofdistinct +0.0 and −0.0 values, which then prohibits simplificationof expressions such as x+0.0 or 0.0*x (even with-ffinite-math-only).This option implies that the sign of a zero result isn’t significant.
The default is-fsigned-zeros.
-fno-trapping-math ¶Compile code assuming that floating-point operations cannot generateuser-visible traps. These traps include division by zero, overflow,underflow, inexact result and invalid operation. This option requiresthat-fno-signaling-nans be in effect. Setting this option mayallow faster code if one relies on “non-stop” IEEE arithmetic, for example.
This option is not turned on by any-O option besides-Ofast since it can result in incorrect output for programsthat depend on an exact implementation of IEEE or ISO rules/specificationsfor math functions.
The default is-ftrapping-math.
Future versions of GCC may provide finer control of this settingusing C99’sFENV_ACCESS pragma. This command-line optionwill be used along with-frounding-math to specify thedefault state forFENV_ACCESS.
-frounding-math ¶Disable transformations and optimizations that assume default floating-pointrounding behavior (round-to-nearest).This option should be specified for programs that changethe FP rounding mode dynamically, or that may be executed with anon-default rounding mode. This option disables constant folding offloating-point expressions at compile time (which may be affected byrounding mode) and arithmetic transformations that are unsafe in thepresence of sign-dependent rounding modes.
The default is-fno-rounding-math.
This option is experimental and does not currently guarantee todisable all GCC optimizations that are affected by rounding mode.Future versions of GCC may provide finer control of this settingusing C99’sFENV_ACCESS pragma. This command-line optionwill be used along with-ftrapping-math to specify thedefault state forFENV_ACCESS.
-fsignaling-nans ¶Compile code assuming that IEEE signaling NaNs may generate user-visibletraps during floating-point operations. Setting this option disablesoptimizations that may change the number of exceptions visible withsignaling NaNs. This option implies-ftrapping-math.
This option causes the preprocessor macro__SUPPORT_SNAN__ tobe defined.
The default is-fno-signaling-nans.
This option is experimental and does not currently guarantee todisable all GCC optimizations that affect signaling NaN behavior.
-fsingle-precision-constant ¶Treat floating-point constants as single precision instead ofimplicitly converting them to double-precision constants.
-fcx-limited-range ¶When enabled, this option states that a range reduction step is notneeded when performing complex division. Also, there is no checkingwhether the result of a complex multiplication or division isNaN+ I*NaN, with an attempt to rescue the situation in that case. Theoption is enabled by-ffast-math.
This option controls the default setting of the ISO C99CX_LIMITED_RANGE pragma. Nevertheless, the option applies toall languages.
-fcx-fortran-rules ¶Complex multiplication and division follow Fortran rules. Rangereduction is done as part of complex division, but there is no checkingwhether the result of a complex multiplication or division isNaN+ I*NaN, with an attempt to rescue the situation in that case.
-fcx-method=method ¶Complex multiplication and division follow the statedmethod. Themethod argument should be one of ‘limited-range’, ‘fortran’or ‘stdc’.
The default is to honor language specific constraints which means‘fortran’ for Fortran and ‘stdc’ otherwise.
The following options control optimizations that may improveperformance, but are not enabled by any-O options. Thissection includes experimental options that may produce broken code.
-fbranch-probabilities ¶After running a program compiled with-fprofile-arcs(seeProgram Instrumentation Options),you can compile it a second time using-fbranch-probabilities, to improve optimizations based onthe number of times each branch was taken. When a programcompiled with-fprofile-arcs exits, it saves arc executioncounts to a file calledsourcename.gcda for each sourcefile. The information in this data file is very dependent on thestructure of the generated code, so you must use the same source codeand the same optimization options for both compilations.See details about the file naming in-fprofile-arcs.
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 onlyused in one place: inreorg.cc, instead of guessing which path abranch is most likely to take, the ‘REG_BR_PROB’ values are used toexactly determine which path is taken more often.
Enabled by-fprofile-use and-fauto-profile.
-fprofile-values ¶If combined with-fprofile-arcs, it adds code so that somedata about values of expressions in the program is gathered.
With-fbranch-probabilities, it reads back the data gatheredfrom profiling values of expressions for usage in optimizations.
Enabled by-fprofile-generate,-fprofile-use, and-fauto-profile.
-fprofile-reorder-functions ¶Function reordering based on profile instrumentation collectsfirst time of execution of a function and orders these functionsin ascending order, aiming to optimize program startup through moreefficient loading of text segments.
Enabled with-fprofile-use.
-fvpt ¶If combined with-fprofile-arcs, this option instructs the compilerto add code to gather information about values of expressions.
With-fbranch-probabilities, it reads back the data gatheredand actually performs the optimizations based on them.Currently the optimizations include specialization of division operationsusing the knowledge about the value of the denominator.
Enabled with-fprofile-use and-fauto-profile.
-frename-registers ¶Attempt to avoid false dependencies in scheduled code by making useof registers left over after register allocation. This optimizationmost benefits processors with lots of registers. Depending on thedebug information format adopted by the target, however, it canmake debugging impossible, since variables no longer stay ina “home register”.
Enabled by default with-funroll-loops.
-fschedule-fusion ¶Performs a target dependent pass over the instruction stream to scheduleinstructions of same type together because target machine can execute themmore efficiently if they are adjacent to each other in the instruction flow.
Enabled at levels-O2,-O3,-Os.
-fdep-fusion ¶Detect macro-op fusible pairs consisting of single-use instructions and theiruses, and place such pairs together in the instruction stream to increasefusion opportunities in hardware. This pass is executed once before registerallocation, and another time before register renaming.
Enabled at levels-O2,-O3,-Os.
-ftracer ¶Perform tail duplication to enlarge superblock size. This transformationsimplifies the control flow of the function allowing other optimizations to doa better job.
Enabled by-fprofile-use and-fauto-profile.
-funroll-loops ¶Unroll loops whose number of iterations can be determined at compile time orupon entry to the loop.-funroll-loops implies-frerun-cse-after-loop,-fweb and-frename-registers.It also turns on complete loop peeling (i.e. complete removal of loops witha small constant number of iterations). This option makes code larger, and mayor may not make it run faster.
Enabled by-fprofile-use and-fauto-profile.
-funroll-all-loops ¶Unroll all loops, even if their number of iterations is uncertain whenthe loop is entered. This usually makes programs run more slowly.-funroll-all-loops implies the same options as-funroll-loops.
-fpeel-loops ¶Peels loops for which there is enough information that they do notroll much (from profile feedback or static analysis). It also turns oncomplete loop peeling (i.e. complete removal of loops with small constantnumber of iterations).
Enabled by-O3,-fprofile-use, and-fauto-profile.
-fmalloc-dce ¶Control whethermalloc (and its variants such ascalloc orstrdup), can be optimized away provided its return value is only usedas a parameter offree call or compared withNULL. If-fmalloc-dce=1 is used, only calls tofree are allowed whilewith-fmalloc-dce=2 also comparisons withNULL pointer areconsidered safe to remove.
The default is-fmalloc-dce=2. See also-fallocation-dce.
-fmove-loop-invariants ¶Enables the loop invariant motion pass in the RTL loop optimizer. Enabledat level-O1 and higher, except for-Og.
-fmove-loop-stores ¶Enables the loop store motion pass in the GIMPLE loop optimizer. Thismoves invariant stores to after the end of the loop in exchange forcarrying the stored value in a register across the iteration.Note for this option to have an effect-ftree-loop-im has tobe enabled as well. Enabled at level-O1 and higher, exceptfor-Og.
-fsplit-loops ¶Split a loop into two if it contains a condition that’s always truefor one side of the iteration space and false for the other.
Enabled by-fprofile-use and-fauto-profile.
-funswitch-loops ¶Move branches with loop invariant conditions out of the loop, with duplicatesof the loop on both branches (modified according to result of the condition).
Enabled by-fprofile-use and-fauto-profile.
-fversion-loops-for-strides ¶If a loop iterates over an array with a variable stride, create anotherversion of the loop that assumes the stride is always one. For example:
for (int i = 0; i < n; ++i) x[i * stride] = …;
becomes:
if (stride == 1) for (int i = 0; i < n; ++i) x[i] = …;else for (int i = 0; i < n; ++i) x[i * stride] = …;
This is particularly useful for assumed-shape arrays in Fortran where(for example) it allows better vectorization assuming contiguous accesses.This flag is enabled by default at-O3.It is also enabled by-fprofile-use and-fauto-profile.
-ffunction-sections ¶-fdata-sectionsPlace each function or data item into its own section in the outputfile if the target supports arbitrary sections. The name of thefunction or the name of the data item determines the section’s namein the output file.
Use these options on systems where the linker can perform optimizations toimprove locality of reference in the instruction space. Most systems using theELF object format have linkers with such optimizations. On AIX, the linkerrearranges sections (CSECTs) based on the call graph. The performance impactvaries.
Together with a linker garbage collection (linker--gc-sectionsoption) these options may lead to smaller statically-linked executables (afterstripping).
On ELF/DWARF systems these options do not degenerate the quality of the debuginformation. There could be issues with other object files/debug info formats.
Only use these options when there are significant benefits from doing so. Whenyou specify these options, the assembler and linker create larger object andexecutable files and are also slower. These options affect code generation.They prevent optimizations by the compiler and assembler using relativelocations inside a translation unit since the locations are unknown untillink time. An example of such an optimization is relaxing calls to short callinstructions.
-fstdarg-opt ¶Optimize the prologue of variadic argument functions with respect to usage ofthose arguments.
-fsection-anchors ¶Try to reduce the number of symbolic address calculations by usingshared “anchor” symbols to address nearby objects. This transformationcan help to reduce the number of GOT entries and GOT accesses on sometargets.
For example, the implementation of the following functionfoo:
static int a, b, c;int foo (void) { return a + b + c; }usually calculates the addresses of all three variables, but if youcompile it with-fsection-anchors, it accesses the variablesfrom a common anchor point instead. The effect is similar to thefollowing 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.
-fzero-call-used-regs=choice ¶Zero call-used registers at function return to increase programsecurity by either mitigating Return-Oriented Programming (ROP)attacks or preventing information leakage through registers.
The possible values ofchoice are the same as for thezero_call_used_regs attribute (seeDeclaring Attributes of Functions).The default is ‘skip’.
You can control this behavior for a specific function by using the functionattributezero_call_used_regs (seeDeclaring Attributes of Functions).
Next:Program Instrumentation Options, Previous:Options for Debugging Your Program, Up:GCC Command Options [Contents][Index]