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-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 parameters, which may bespecified individually by using--paramname=value.The-finline-limit=n option sets some of these parametersas follows:
max-inline-insns-singleis set ton/2.
max-inline-insns-autois set ton/2.
See below for a documentation of the individualparameters controlling inlining and for the defaults of these parameters.
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
-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.
-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(see--param ipa-cp-unit-growth=value).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.
-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).
--paramname=value ¶--param=name=valueIn some places, GCC uses various constants to control the amount ofoptimization that is done. For example, GCC does not inline functionsthat contain more than a certain number of instructions. You cancontrol some of these constants on the command line using the--param option.
The names of specific parameters, and the meaning of the values, aretied to the internals of the compiler, and are subject to changewithout notice in future releases.
In order to get the minimal, maximal and default values of a parameter,use the--help=param -Q options.
In each case, thevalue is an integer. The following choicesofname are recognized for all targets:
auto-profile-bbsIf non-zero and used together with-fauto-profile, the auto-profilewill be used to determine basic block profile. If zero, then only functionlevel profile will be read.
phiopt-factor-max-stmts-liveWhen factoring statements out of if/then/else, this is the max # of statementsafter the defining statement to be allow to extend the lifetime of a name
predictable-branch-outcomeWhen branch is predicted to be taken with probability lower than this threshold(in percent), then it is considered well predictable.
max-rtl-if-conversion-insnsRTL if-conversion tries to remove conditional branches around a block andreplace them with conditionally executed instructions. This parametergives the maximum number of instructions in a block which should beconsidered for if-conversion. The compiler willalso use other heuristics to decide whether if-conversion is likely to beprofitable.
file-cache-filesMax number of files in the file cache.The file cache is used to print source lines in diagnostics and do somesource checks like-Wmisleading-indentation.
file-cache-linesMax number of lines to index into file cache. When 0 this is automatically sized.The file cache is used to print source lines in diagnostics and do somesource checks like-Wmisleading-indentation.
max-rtl-if-conversion-predictable-costRTL if-conversion will try to remove conditional branches around a blockand replace them with conditionally executed instructions. These parametersgive the maximum permissible cost for the sequence that would be generatedby if-conversion depending on whether the branch is statically determinedto be predictable or not. The units for this parameter are the same asthose for the GCC internal seq_cost metric. The compiler will try toprovide a reasonable default for this parameter using the BRANCH_COSTtarget macro.
max-crossjump-edgesThe maximum number of incoming edges to consider for cross-jumping.The algorithm used by-fcrossjumping isO(N^2) inthe number of edges incoming to each block. Increasing values meanmore aggressive optimization, making the compilation time increase withprobably small improvement in executable size.
min-crossjump-insnsThe minimum number of instructions that must be matched at the endof two blocks before cross-jumping is performed on them. Thisvalue is ignored in the case where all instructions in the block beingcross-jumped from are matched.
max-grow-copy-bb-insnsThe maximum code size expansion factor when copying basic blocksinstead of jumping. The expansion is relative to a jump instruction.
max-goto-duplication-insnsThe maximum number of instructions to duplicate to a block that jumpsto a computed goto. To avoidO(N^2) behavior in a number ofpasses, GCC factors computed gotos early in the compilation process,and unfactors them as late as possible. Only computed jumps at theend of a basic blocks with no more than max-goto-duplication-insns areunfactored.
max-delay-slot-insn-searchThe maximum number of instructions to consider when looking for aninstruction to fill a delay slot. If more than this arbitrary number ofinstructions are searched, the time savings from filling the delay slotare minimal, so stop searching. Increasing values mean moreaggressive optimization, making the compilation time increase with probablysmall improvement in execution time.
max-delay-slot-live-searchWhen trying to fill delay slots, the maximum number of instructions toconsider when searching for a block with valid live registerinformation. Increasing this arbitrarily chosen value means moreaggressive optimization, increasing the compilation time. This parametershould be removed when the delay slot code is rewritten to maintain thecontrol-flow graph.
max-devirt-targetsThis limits number of function a virtual call may be speculativelydevirtualized to using static analysis (without profile feedback).
max-gcse-memoryThe approximate maximum amount of memory inkB that can be allocated inorder to perform the global common subexpression eliminationoptimization. If more memory than specified is required, theoptimization is not done.
max-gcse-insertion-ratioIf the ratio of expression insertions to deletions is larger than this valuefor any expression, then RTL PRE inserts or removes the expression and thusleaves partially redundant computations in the instruction stream.
max-pending-list-lengthThe maximum number of pending dependencies scheduling allowsbefore flushing the current state and starting over. Large functionswith few branches or calls can create excessively large lists whichneedlessly consume memory and resources.
max-modulo-backtrack-attemptsThe maximum number of backtrack attempts the scheduler should makewhen modulo scheduling a loop. Larger values can exponentially increasecompilation time.
max-inline-functions-called-once-loop-depthMaximal loop depth of a call considered by inline heuristics that tries toinline all functions called once.
max-inline-functions-called-once-insnsMaximal estimated size of functions produced while inlining functions calledonce.
max-inline-insns-singleSeveral parameters control the tree inliner used in GCC. This number sets themaximum number of instructions (counted in GCC’s internal representation) in asingle function that the tree inliner considers for inlining. This onlyaffects functions declared inline and methods implemented in a classdeclaration (C++).
max-inline-insns-autoWhen you use-finline-functions (included in-O3),a lot of functions that would otherwise not be considered for inliningby the compiler are investigated. To those functions, a different(more restrictive) limit compared to functions declared inline canbe applied (--param max-inline-insns-auto).
max-inline-insns-smallThis is the bound applied to calls that are considered relevant with-finline-small-functions.
max-inline-insns-sizeThis is the bound applied to calls that are optimized for size. Small growthmay be desirable to anticipate optimization opportunities exposed by inlining.
uninlined-function-insnsNumber of instructions accounted by inliner for function overhead such asfunction prologue and epilogue.
uninlined-function-timeExtra time accounted by inliner for function overhead such as time needed toexecute function prologue and epilogue.
inline-heuristics-hint-percentThe scale (in percents) applied toinline-insns-single,inline-insns-single-O2,inline-insns-autowhen inline heuristics hints that inlining isvery profitable (will enable later optimizations).
uninlined-thunk-insnsuninlined-thunk-timeSame as--param uninlined-function-insns and--param uninlined-function-time but applied to function thunks.
inline-min-speedupWhen estimated performance improvement of caller + callee runtime exceeds thisthreshold (in percent), the function can be inlined regardless of the limit on--param max-inline-insns-single and--parammax-inline-insns-auto.
large-function-insnsThe limit specifying really large functions. For functions larger than thislimit after inlining, inlining is constrained by--param large-function-growth. This parameter is useful primarilyto avoid extreme compilation time caused by non-linear algorithms used by theback end.
large-function-growthSpecifies maximal growth of large functions caused by inlining in percents.For example, parameter value 100 limits large function growth to 2.0 timesthe original size.
large-unit-insnsThe limit specifying large translation unit. Growth caused by inlining ofunits larger than this limit is limited by--param inline-unit-growth.For small units this might be too tight.For example, consider a unit consisting of function Athat is inline and B that just calls A three times. If B is small relative toA, the growth of unit is 300\% and yet such inlining is very sane. For verylarge units consisting of small inlineable functions, however, the overall unitgrowth limit is needed to avoid exponential explosion of code size. Thus forsmaller units, the size is increased to--param large-unit-insnsbefore applying--param inline-unit-growth.
lazy-modulesMaximum number of concurrently open C++ module files when lazy loading.
inline-unit-growthSpecifies maximal overall growth of the compilation unit caused by inlining.For example, parameter value 20 limits unit growth to 1.2 times the originalsize. Cold functions (either marked cold via an attribute or by profilefeedback) are not accounted into the unit size.
ipa-cp-unit-growthSpecifies maximal overall growth of the compilation unit caused byinterprocedural constant propagation. For example, parameter value 10 limitsunit growth to 1.1 times the original size.
ipa-cp-large-unit-insnsThe size of translation unit that IPA-CP pass considers large.
large-stack-frameThe limit specifying large stack frames. While inlining the algorithm is tryingto not grow past this limit too much.
large-stack-frame-growthSpecifies maximal growth of large stack frames caused by inlining in percents.For example, parameter value 1000 limits large stack frame growth to 11 timesthe original size.
max-inline-insns-recursivemax-inline-insns-recursive-autoSpecifies the maximum number of instructions an out-of-line copy of aself-recursive inlinefunction can grow into by performing recursive inlining.
--param max-inline-insns-recursive applies to functionsdeclared inline.For functions not declared inline, recursive inlininghappens only when-finline-functions (included in-O3) isenabled;--param max-inline-insns-recursive-auto applies instead.
max-inline-recursive-depthmax-inline-recursive-depth-autoSpecifies the maximum recursion depth used for recursive inlining.
--param max-inline-recursive-depth applies to functionsdeclared inline. For functions not declared inline, recursive inlininghappens only when-finline-functions (included in-O3) isenabled;--param max-inline-recursive-depth-auto applies instead.
min-inline-recursive-probabilityRecursive inlining is profitable only for function having deep recursionin average and can hurt for function having little recursion depth byincreasing the prologue size or complexity of function body to otheroptimizers.
When profile feedback is available (see-fprofile-generate) the actualrecursion depth can be guessed from the probability that function recursesvia a given call expression. This parameter limits inlining only to callexpressions whose probability exceeds the given threshold (in percents).
early-inlining-insnsSpecify growth that the early inliner can make. In effect it increasesthe amount of inlining for code having a large abstraction penalty.
max-early-inliner-iterationsLimit of iterations of the early inliner. This basically boundsthe number of nested indirect calls the early inliner can resolve.Deeper chains are still handled by late inlining.
comdat-sharing-probabilityProbability (in percent) that C++ inline function with comdat visibilityare shared across multiple compilation units.
modref-max-basesmodref-max-refsmodref-max-accessesSpecifies the maximal number of base pointers, references and accesses storedfor a single function by mod/ref analysis.
modref-max-testsSpecifies the maxmal number of tests alias oracle can perform to disambiguatememory locations using the mod/ref information. This parameter ought to bebigger than--param modref-max-bases and--parammodref-max-refs.
modref-max-depthSpecifies the maximum depth of DFS walk used by modref escape analysis.Setting to 0 disables the analysis completely.
modref-max-escape-pointsSpecifies the maximum number of escape points tracked by modref per SSA-name.
modref-max-adjustmentsSpecifies the maximum number the access range is enlarged during modref dataflowanalysis.
profile-func-internal-idA parameter to control whether to use function internal id in profiledatabase lookup. If the value is 0, the compiler uses an id thatis based on function assembler name and filename, which makes old profiledata more tolerant to source changes such as function reordering etc.
min-vect-loop-boundThe minimum number of iterations under which loops are not vectorizedwhen-ftree-vectorize is used. The number of iterations aftervectorization needs to be greater than the value specified by this optionto allow vectorization.
gcse-cost-distance-ratioScaling factor in calculation of maximum distance an expressioncan be moved by GCSE optimizations. This is currently supported only in thecode hoisting pass. The bigger the ratio, the more aggressive code hoistingis with simple expressions, i.e., the expressions that have costless thangcse-unrestricted-cost. Specifying 0 disableshoisting of simple expressions.
gcse-unrestricted-costCost, roughly measured as the cost of a single typical machineinstruction, at which GCSE optimizations do not constrainthe distance an expression can travel. This is currentlysupported only in the code hoisting pass. The lesser the cost,the more aggressive code hoisting is. Specifying 0allows all expressions to travel unrestricted distances.
max-hoist-depthThe depth of search in the dominator tree for expressions to hoist.This is used to avoid quadratic behavior in hoisting algorithm.The value of 0 does not limit on the search, but may slow down compilationof huge functions.
max-tail-merge-comparisonsThe maximum amount of similar bbs to compare a bb with. This is used toavoid quadratic behavior in tree tail merging.
max-tail-merge-iterationsThe maximum amount of iterations of the pass over the function. This is used tolimit compilation time in tree tail merging.
store-merging-allow-unalignedAllow the store merging pass to introduce unaligned stores if it is legal todo so.
max-stores-to-mergeThe maximum number of stores to attempt to merge into wider stores in the storemerging pass.
max-store-chains-to-trackThe maximum number of store chains to track at the same time in the attemptto merge them into wider stores in the store merging pass.
max-stores-to-trackThe maximum number of stores to track at the same time in the attemt toto merge them into wider stores in the store merging pass.
max-unrolled-insnsThe maximum number of instructions that a loop may have to be unrolled.If a loop is unrolled, this parameter also determines how many timesthe loop code is unrolled.
max-average-unrolled-insnsThe maximum number of instructions biased by probabilities of their executionthat a loop may have to be unrolled. If a loop is unrolled,this parameter also determines how many times the loop code is unrolled.
max-unroll-timesThe maximum number of unrollings of a single loop.
max-peeled-insnsThe maximum number of instructions that a loop may have to be peeled.If a loop is peeled, this parameter also determines how many timesthe loop code is peeled.
max-peel-timesThe maximum number of peelings of a single loop.
max-peel-branchesThe maximum number of branches on the hot path through the peeled sequence.
max-completely-peeled-insnsThe maximum number of insns of a completely peeled loop.
max-completely-peel-timesThe maximum number of iterations of a loop to be suitable for complete peeling.
max-completely-peel-loop-nest-depthThe maximum depth of a loop nest suitable for complete peeling.
max-unswitch-insnsThe maximum number of insns of an unswitched loop.
max-unswitch-depthThe maximum depth of a loop nest to be unswitched.
lim-expensiveThe minimum cost of an expensive expression in the loop invariant motion.
min-loop-cond-split-probWhen FDO profile information is available,min-loop-cond-split-probspecifies minimum threshold for probability of semi-invariant conditionstatement to trigger loop split.
iv-consider-all-candidates-boundBound on number of candidates for induction variables, below whichall candidates are considered for each use in induction variableoptimizations. If there are more candidates than this,only the most relevant ones are considered to avoid quadratic time complexity.
iv-max-considered-usesThe induction variable optimizations give up on loops that contain moreinduction variable uses.
iv-always-prune-cand-set-boundIf the number of candidates in the set is smaller than this value,always try to remove unnecessary ivs from the setwhen adding a new one.
avg-loop-niterAverage number of iterations of a loop.
dse-max-object-sizeMaximum size (in bytes) of objects tracked bytewise by dead store elimination.Larger values may result in larger compilation times.
dse-max-alias-queries-per-storeMaximum number of queries into the alias oracle per store.Larger values result in larger compilation times and may result in moreremoved dead stores.
scev-max-expr-sizeBound on size of expressions used in the scalar evolutions analyzer.Large expressions slow the analyzer.
scev-max-expr-complexityBound on the complexity of the expressions in the scalar evolutions analyzer.Complex expressions slow the analyzer.
max-tree-if-conversion-phi-argsMaximum number of arguments in a PHI supported by TREE if conversionunless the loop is marked with simd pragma.
vect-max-layout-candidatesThe maximum number of possible vector layouts (such as permutations)to consider when optimizing to-be-vectorized code.
vect-max-version-for-alignment-checksThe maximum number of run-time checks that can be performed whendoing loop versioning for alignment in the vectorizer.
vect-max-version-for-alias-checksThe maximum number of run-time checks that can be performed whendoing loop versioning for alias in the vectorizer.
vect-max-peeling-for-alignmentThe maximum number of loop peels to enhance access alignmentfor vectorizer. Value -1 means no limit.
max-iterations-to-trackThe maximum number of iterations of a loop the brute-force algorithmfor analysis of the number of iterations of the loop tries to evaluate.
hot-bb-count-fractionThe denominator n of fraction 1/n of the maximal execution count of abasic block in the entire program that a basic block needs to at leasthave in order to be considered hot. The default is 10000, which meansthat a basic block is considered hot if its execution count is greaterthan 1/10000 of the maximal execution count. 0 means that it is neverconsidered hot. Used in non-LTO mode.
hot-bb-count-ws-permilleThe number of most executed permilles, ranging from 0 to 1000, of theprofiled execution of the entire program to which the execution countof a basic block must be part of in order to be considered hot. Thedefault is 990, which means that a basic block is considered hot ifits execution count contributes to the upper 990 permilles, or 99.0%,of the profiled execution of the entire program. 0 means that it isnever considered hot. Used in LTO mode.
hot-bb-frequency-fractionThe denominator n of fraction 1/n of the execution frequency of theentry block of a function that a basic block of this function needsto at least have in order to be considered hot. The default is 1000,which means that a basic block is considered hot in a function if itis executed more frequently than 1/1000 of the frequency of the entryblock of the function. 0 means that it is never considered hot.
unlikely-bb-count-fractionThe denominator n of fraction 1/n of the number of profiled runs ofthe entire program below which the execution count of a basic blockmust be in order for the basic block to be considered unlikely executed.The default is 20, which means that a basic block is considered unlikelyexecuted if it is executed in fewer than 1/20, or 5%, of the runs ofthe program. 0 means that it is always considered unlikely executed.
max-predicted-iterationsThe maximum number of loop iterations we predict statically. This is usefulin cases where a function contains a single loop with known bound andanother loop with unknown bound.The known number of iterations is predicted correctly, whilethe unknown number of iterations average to roughly 10. This means that theloop without bounds appears artificially cold relative to the other one.
builtin-expect-probabilityControl the probability of the expression having the specified value. Thisparameter takes a percentage (i.e. 0 ... 100) as input.
builtin-string-cmp-inline-lengthThe maximum length of a constant string for a builtin string cmp calleligible for inlining.
align-thresholdSelect fraction of the maximal frequency of executions of a basic block ina function to align the basic block.
align-loop-iterationsA loop expected to iterate at least the selected number of iterations isaligned.
tracer-dynamic-coveragetracer-dynamic-coverage-feedbackThis value is used to limit superblock formation once the given percentage ofexecuted instructions is covered. This limits unnecessary code sizeexpansion.
Thetracer-dynamic-coverage-feedback parameteris used only when profilefeedback is available. The real profiles (as opposed to statically estimatedones) are much less balanced allowing the threshold to be larger value.
tracer-max-code-growthStop tail duplication once code growth has reached given percentage. This isa rather artificial limit, as most of the duplicates are eliminated later incross jumping, so it may be set to much higher values than is the desired codegrowth.
tracer-min-branch-ratioStop reverse growth when the reverse probability of best edge is less than thisthreshold (in percent).
tracer-min-branch-probabilitytracer-min-branch-probability-feedbackStop forward growth if the best edge has probability lower than thisthreshold.
Similarly totracer-dynamic-coverage two parameters areprovided.tracer-min-branch-probability-feedback is used forcompilation with profile feedback andtracer-min-branch-probabilitycompilation without. The value for compilation with profile feedbackneeds to be more conservative (higher) in order to make tracereffective.
stack-clash-protection-guard-sizeSpecify the size of the operating system provided stack guard as2 raised tonum bytes. Higher values may reduce thenumber of explicit probes, but a value larger than the operating systemprovided guard will leave code vulnerable to stack clash style attacks.
stack-clash-protection-probe-intervalStack clash protection involves probing stack space as it is allocated. Thisparam controls the maximum distance between probes into the stack as 2 raisedtonum bytes. Higher values may reduce the number of explicit probes, but a valuelarger than the operating system provided guard will leave code vulnerable tostack clash style attacks.
max-cse-path-lengthThe maximum number of basic blocks on path that CSE considers.
max-cse-insnsThe maximum number of instructions CSE processes before flushing.
ggc-min-expandGCC uses a garbage collector to manage its own memory allocation. Thisparameter specifies the minimum percentage by which the garbagecollector’s heap should be allowed to expand between collections.Tuning this may improve compilation speed; it has no effect on codegeneration.
The default is 30% + 70% * (RAM/1GB) with an upper bound of 100% whenRAM >= 1GB. Ifgetrlimit is available, the notion of “RAM” isthe smallest of actual RAM andRLIMIT_DATA orRLIMIT_AS. IfGCC is not able to calculate RAM on a particular platform, the lowerbound of 30% is used. Setting this parameter andggc-min-heapsize to zero causes a full collection to occur atevery opportunity. This is extremely slow, but can be useful fordebugging.
ggc-min-heapsizeMinimum size of the garbage collector’s heap before it begins botheringto collect garbage. The first collection occurs after the heap expandsbyggc-min-expand% beyondggc-min-heapsize. Again,tuning this may improve compilation speed, and has no effect on codegeneration.
The default is the smaller of RAM/8, RLIMIT_RSS, or a limit thattries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, butwith a lower bound of 4096 (four megabytes) and an upper bound of131072 (128 megabytes). If GCC is not able to calculate RAM on aparticular platform, the lower bound is used. Setting this parametervery large effectively disables garbage collection. Setting thisparameter andggc-min-expand to zero causes a full collectionto occur at every opportunity.
max-reload-search-insnsThe maximum number of instruction reload should look backward for equivalentregister. Increasing values mean more aggressive optimization, making thecompilation time increase with probably slightly better performance.
max-cselib-memory-locationsThe maximum number of memory locations cselib should take into account.Increasing values mean more aggressive optimization, making the compilation timeincrease with probably slightly better performance.
max-sched-ready-insnsThe maximum number of instructions ready to be issued the scheduler shouldconsider at any given time during the first scheduling pass. Increasingvalues mean more thorough searches, making the compilation time increasewith probably little benefit.
max-sched-region-blocksThe maximum number of blocks in a region to be considered forinterblock scheduling.
max-pipeline-region-blocksThe maximum number of blocks in a region to be considered forpipelining in the selective scheduler.
max-sched-region-insnsThe maximum number of insns in a region to be considered forinterblock scheduling.
max-pipeline-region-insnsThe maximum number of insns in a region to be considered forpipelining in the selective scheduler.
min-spec-probThe minimum probability (in percents) of reaching a source blockfor interblock speculative scheduling.
max-sched-extend-regions-itersThe maximum number of iterations through CFG to extend regions.A value of 0 disables region extensions.
max-sched-insn-conflict-delayThe maximum conflict delay for an insn to be considered for speculative motion.
sched-spec-prob-cutoffThe minimal probability of speculation success (in percents), so thatspeculative insns are scheduled.
sched-state-edge-prob-cutoffThe minimum probability an edge must have for the scheduler to save itsstate across it.
sched-mem-true-dep-costMinimal distance (in CPU cycles) between store and load targeting samememory locations.
selsched-max-lookaheadThe maximum size of the lookahead window of selective scheduling. It is adepth of search for available instructions.
selsched-max-sched-timesThe maximum number of times that an instruction is scheduled duringselective scheduling. This is the limit on the number of iterationsthrough which the instruction may be pipelined.
selsched-insns-to-renameThe maximum number of best instructions in the ready list that are consideredfor renaming in the selective scheduler.
sms-min-scThe minimum value of stage count that swing modulo schedulergenerates.
max-last-value-rtlThe maximum size measured as number of RTLs that can be recorded in an expressionin combiner for a pseudo register as last known value of that register.
max-combine-insnsThe maximum number of instructions the RTL combiner tries to combine.
max-combine-search-insnsThe maximum number of instructions that the RTL combiner searches in orderto find the next use of a given register definition. If this limit is reachedwithout finding such a use, the combiner will stop trying to optimize thedefinition.
Currently this limit only applies after certain successful combinationattempts, but it could be extended to other cases in future.
integer-share-limitSmall integer constants can use a shared data structure, reducing thecompiler’s memory usage and increasing its speed. This sets the maximumvalue of a shared integer constant.
ssp-buffer-sizeThe minimum size of buffers (i.e. arrays) that receive stack smashingprotection when-fstack-protector is used.
min-size-for-stack-sharingThe minimum size of variables taking part in stack slot sharing when notoptimizing.
max-jump-thread-duplication-stmtsMaximum number of statements allowed in a block that needs to beduplicated when threading jumps.
max-jump-thread-pathsThe maximum number of paths to consider when searching for jump threadingopportunities. When arriving at a block, incoming edges are only consideredif the number of paths to be searched so far multiplied by the number ofincoming edges does not exhaust the specified maximum number of paths toconsider.
max-fields-for-field-sensitiveMaximum number of fields in a structure treated ina field sensitive manner during pointer analysis.
prefetch-latencyEstimate on average number of instructions that are executed beforeprefetch finishes. The distance prefetched ahead is proportionalto this constant. Increasing this number may also lead to lessstreams being prefetched (seesimultaneous-prefetches).
simultaneous-prefetchesMaximum number of prefetches that can run at the same time.
l1-cache-line-sizeThe size of cache line in L1 data cache, in bytes.
l1-cache-sizeThe size of L1 data cache, in kilobytes.
l2-cache-sizeThe size of L2 data cache, in kilobytes.
prefetch-dynamic-stridesWhether the loop array prefetch pass should issue software prefetch hintsfor strides that are non-constant. In some cases this may bebeneficial, though the fact the stride is non-constant may make ithard to predict when there is clear benefit to issuing these hints.
Set to 1 if the prefetch hints should be issued for non-constantstrides. Set to 0 if prefetch hints should be issued only for strides thatare known to be constant and belowprefetch-minimum-stride.
prefetch-minimum-strideMinimum constant stride, in bytes, to start using prefetch hints for. Ifthe stride is less than this threshold, prefetch hints will not be issued.
This setting is useful for processors that have hardware prefetchers, inwhich case there may be conflicts between the hardware prefetchers andthe software prefetchers. If the hardware prefetchers have a maximumstride they can handle, it should be used here to improve the use ofsoftware prefetchers.
A value of -1 means we don’t have a threshold and thereforeprefetch hints can be issued for any constant stride.
This setting is only useful for strides that are known and constant.
destructive-interference-sizeconstructive-interference-sizeThe values for the C++17 variablesstd::hardware_destructive_interference_size andstd::hardware_constructive_interference_size. The destructiveinterference size is the minimum recommended offset between twoindependent concurrently-accessed objects; the constructiveinterference size is the maximum recommended size of contiguous memoryaccessed together. Typically both will be the size of an L1 cacheline for the target, in bytes. For a generic target covering a range of L1cache line sizes, typically the constructive interference size will bethe small end of the range and the destructive size will be the largeend.
The destructive interference size is intended to be used for layout,and thus has ABI impact. The default value is not expected to bestable, and on some targets varies with-mtune, so use ofthis variable in a context where ABI stability is important, such asthe public interface of a library, is strongly discouraged; if it isused in that context, users can stabilize the value using thisoption.
The constructive interference size is less sensitive, as it istypically only used in a ‘static_assert’ to make sure that a typefits within a cache line.
See also-Winterference-size.
loop-interchange-max-num-stmtsThe maximum number of stmts in a loop to be interchanged.
loop-interchange-stride-ratioThe minimum ratio between stride of two loops for interchange to be profitable.
min-insn-to-prefetch-ratioThe minimum ratio between the number of instructions and thenumber of prefetches to enable prefetching in a loop.
prefetch-min-insn-to-mem-ratioThe minimum ratio between the number of instructions and thenumber of memory references to enable prefetching in a loop.
use-canonical-typesWhether the compiler should use the “canonical” type system.Should always be 1, which uses a more efficient internalmechanism for comparing types in C++ and Objective-C++. However, ifbugs in the canonical type system are causing compilation failures,set this value to 0 to disable canonical types.
switch-conversion-max-branch-ratioSwitch initialization conversion refuses to create arrays that arebigger thanswitch-conversion-max-branch-ratio times the number ofbranches in the switch.
max-partial-antic-lengthMaximum length of the partial antic set computed during the treepartial redundancy elimination optimization (-ftree-pre) whenoptimizing at-O3 and above. For some sorts of source codethe enhanced partial redundancy elimination optimization can run away,consuming all of the memory available on the host machine. Thisparameter sets a limit on the length of the sets that are computed,which prevents the runaway behavior. Setting a value of 0 forthis parameter allows an unlimited set length.
rpo-vn-max-loop-depthMaximum loop depth that is value-numbered optimistically.When the limit hits the innermostrpo-vn-max-loop-depth loops and the outermost loop in theloop nest are value-numbered optimistically and the remaining ones not.
sccvn-max-alias-queries-per-accessMaximum number of alias-oracle queries we perform when looking forredundancies for loads and stores. If this limit is hit the searchis aborted and the load or store is not considered redundant. Thenumber of queries is algorithmically limited to the number ofstores on all paths from the load to the function entry.
ira-max-loops-numIRA uses regional register allocation by default. If a functioncontains more loops than the number given by this parameter, only at mostthe given number of the most frequently-executed loops form regionsfor regional register allocation.
ira-max-conflict-table-sizeAlthough IRA uses a sophisticated algorithm to compress the conflicttable, the table can still require excessive amounts of memory forhuge functions. If the conflict table for a function could be morethan the size in MB given by this parameter, the register allocatorinstead uses a faster, simpler, and lower-qualityalgorithm that does not require building a pseudo-register conflict table.
ira-loop-reserved-regsIRA can be used to evaluate more accurate register pressure in loopsfor decisions to move loop invariants (see-O3). The numberof available registers reserved for some other purposes is givenby this parameter. Default of the parameteris the best found from numerous experiments.
ira-consider-dup-in-all-altsMake IRA to consider matching constraint (duplicated operand number)heavily in all available alternatives for preferred register class.If it is set as zero, it means IRA only respects the matchingconstraint when it’s in the only available alternative with anappropriate register class. Otherwise, it means IRA will check allavailable alternatives for preferred register class even if it hasfound some choice with an appropriate register class and respect thefound qualified matching constraint.
ira-simple-lra-insn-thresholdApproximate function insn number in 1K units triggering simple local RA.
lra-inheritance-ebb-probability-cutoffLRA tries to reuse values reloaded in registers in subsequent insns.This optimization is called inheritance. EBB is used as a region todo this optimization. The parameter defines a minimal fall-throughedge probability in percentage used to add BB to inheritance EBB inLRA. The default value was chosenfrom numerous runs of SPEC2000 on x86-64.
loop-invariant-max-bbs-in-loopLoop invariant motion can be very expensive, both in compilation time andin amount of needed compile-time memory, with very large loops. Loopswith more basic blocks than this parameter won’t have loop invariantmotion optimization performed on them.
loop-max-datarefs-for-datadepsBuilding data dependencies is expensive for very large loops. Thisparameter limits the number of data references in loops that areconsidered for data dependence analysis. These large loops are nohandled by the optimizations using loop data dependencies.
max-vartrack-sizeSets a maximum number of hash table slots to use during variabletracking dataflow analysis of any function. If this limit is exceededwith variable tracking at assignments enabled, analysis for thatfunction is retried without it, after removing all debug insns fromthe function. If the limit is exceeded even without debug insns, vartracking analysis is completely disabled for the function. Settingthe parameter to zero makes it unlimited.
max-vartrack-expr-depthSets a maximum number of recursion levels when attempting to mapvariable names or debug temporaries to value expressions. This tradescompilation time for more complete debug information. If this is set toolow, value expressions that are available and could be represented indebug information may end up not being used; setting this higher mayenable the compiler to find more complex debug expressions, but compiletime and memory use may grow.
max-debug-marker-countSets a threshold on the number of debug markers (e.g. begin stmtmarkers) to avoid complexity explosion at inlining or expanding to RTL.If a function has more such gimple stmts than the set limit, such stmtswill be dropped from the inlined copy of a function, and from its RTLexpansion.
min-nondebug-insn-uidUse uids starting at this parameter for nondebug insns. The range belowthe parameter is reserved exclusively for debug insns created by-fvar-tracking-assignments, but debug insns may get(non-overlapping) uids above it if the reserved range is exhausted.
ipa-sra-deref-prob-thresholdIPA-SRA replaces a pointer which is known not be NULL with one or morenew parameters only when the probability (in percent, relative tofunction entry) of it being dereferenced is higher than this parameter.
ipa-sra-ptr-growth-factorIPA-SRA replaces a pointer to an aggregate with one or more newparameters only when their cumulative size is less or equal toipa-sra-ptr-growth-factor times the size of the originalpointer parameter.
ipa-sra-ptrwrap-growth-factorAdditional maximum allowed growth of total size of new parametersthat ipa-sra replaces a pointer to an aggregate with,if it points to a local variable that the caller only writes to andpasses it as an argument to other functions.
ipa-sra-max-replacementsMaximum pieces of an aggregate that IPA-SRA tracks. As aconsequence, it is also the maximum number of replacements of a formalparameter.
sra-max-scalarization-size-Ospeedsra-max-scalarization-size-OsizeThe two Scalar Reduction of Aggregates passes (SRA and IPA-SRA) aim toreplace scalar parts of aggregates with uses of independent scalarvariables. These parameters control the maximum size, in storage units,of aggregate which is considered for replacement when compiling forspeed(sra-max-scalarization-size-Ospeed) or size(sra-max-scalarization-size-Osize) respectively.
sra-max-propagationsThe maximum number of artificial accesses that Scalar Replacement ofAggregates (SRA) will track, per one local variable, in order tofacilitate copy propagation.
tm-max-aggregate-sizeWhen making copies of thread-local variables in a transaction, thisparameter specifies the size in bytes after which variables aresaved with the logging functions as opposed to save/restore codesequence pairs. This option only applies when using-fgnu-tm.
graphite-max-nb-scop-paramsTo avoid exponential effects in the Graphite loop transforms, thenumber of parameters in a Static Control Part (SCoP) is bounded.A value of zero can be used to liftthe bound. A variable whose value is unknown at compilation time anddefined outside a SCoP is a parameter of the SCoP.
hardcfr-max-blocksDisable-fharden-control-flow-redundancy for functions with alarger number of blocks than the specified value. Zero removes anylimit.
hardcfr-max-inline-blocksForce-fharden-control-flow-redundancy to use out-of-linechecking for functions with a larger number of basic blocks than thespecified value.
loop-block-tile-sizeLoop blocking or strip mining transforms, enabled with-floop-block or-floop-strip-mine, strip mine eachloop in the loop nest by a given number of iterations. The striplength can be changed using theloop-block-tile-sizeparameter.
ipa-jump-function-lookupsSpecifies number of statements visited during jump function offset discovery.
ipa-cp-value-list-sizeIPA-CP attempts to track all possible values and types passed to a function’sparameter in order to propagate them and perform devirtualization.ipa-cp-value-list-size is the maximum number of values and types itstores per one formal parameter of a function.
ipa-cp-eval-thresholdIPA-CP calculates its own score of cloning profitability heuristicsand performs those cloning opportunities with scores that exceedipa-cp-eval-threshold.
ipa-cp-max-recursive-depthMaximum depth of recursive cloning for self-recursive function.
ipa-cp-min-recursive-probabilityRecursive cloning only when the probability of call being executed exceedsthe parameter.
ipa-cp-recursive-freq-factorThe number of times interprocedural copy propagation expects recursivefunctions to call themselves.
ipa-cp-recursion-penaltyPercentage penalty the recursive functions will receive when theyare evaluated for cloning.
ipa-cp-single-call-penaltyPercentage penalty functions containing a single call to anotherfunction will receive when they are evaluated for cloning.
ipa-max-agg-itemsIPA-CP is also capable to propagate a number of scalar values passedin an aggregate.ipa-max-agg-items controls the maximumnumber of such values per one parameter.
ipa-cp-loop-hint-bonusWhen IPA-CP determines that a cloning candidate would make the numberof iterations of a loop known, it adds a bonus ofipa-cp-loop-hint-bonus to the profitability score ofthe candidate.
ipa-max-loop-predicatesThe maximum number of different predicates IPA will use to describe whenloops in a function have known properties.
ipa-max-aa-stepsDuring its analysis of function bodies, IPA-CP employs alias analysisin order to track values pointed to by function parameters. In ordernot spend too much time analyzing huge functions, it gives up andconsider all memory clobbered after examiningipa-max-aa-steps statements modifying memory.
ipa-max-switch-predicate-boundsMaximal number of boundary endpoints of case ranges of switch statement.For switch exceeding this limit, IPA-CP will not construct cloning costpredicate, which is used to estimate cloning benefit, for default caseof the switch statement.
ipa-max-param-expr-opsIPA-CP will analyze conditional statement that references some functionparameter to estimate benefit for cloning upon certain constant value.But if number of operations in a parameter expression exceedsipa-max-param-expr-ops, the expression is treated as complicatedone, and is not handled by IPA analysis.
lto-partitionsSpecify desired number of partitions produced during WHOPR compilation.The number of partitions should exceed the number of CPUs used for compilation.
lto-min-partitionSize of minimal partition for WHOPR (in estimated instructions).This prevents expenses of splitting very small programs into too manypartitions.
lto-max-partitionSize of max partition for WHOPR (in estimated instructions).to provide an upper bound for individual size of partition.Meant to be used only with balanced partitioning.
lto-partition-locality-frequency-cutoffThe denominator n of fraction 1/n of the execution frequency of callee to becloned for a particular caller. Special value of 0 dictates to always clonewithout a cut-off.
lto-partition-locality-size-cutoffSize cut-off for callee including inlined calls to be cloned for a particularcaller.
lto-max-locality-partitionMaximal size of a locality partition for LTO (in estimated instructions).Value of 0 results in default value being used.
lto-max-streaming-parallelismMaximal number of parallel processes used for LTO streaming.
cxx-max-namespaces-for-diagnostic-helpThe maximum number of namespaces to consult for suggestions when C++name lookup fails for an identifier.
sink-frequency-thresholdThe maximum relative execution frequency (in percents) of the target blockrelative to a statement’s original block to allow statement sinking of astatement. Larger numbers result in more aggressive statement sinking.A small positive adjustment is applied forstatements with memory operands as those are even more profitable so sink.
max-stores-to-sinkThe maximum number of conditional store pairs that can be sunk. Set to 0if either vectorization (-ftree-vectorize) or if-conversion(-ftree-loop-if-convert) is disabled.
case-values-thresholdThe smallest number of different values for which it is best to use ajump-table instead of a tree of conditional branches. If the value is0, use the default for the machine.
jump-table-max-growth-ratio-for-sizeThe maximum code size growth ratio when expandinginto a jump table (in percent). The parameter is used whenoptimizing for size.
jump-table-max-growth-ratio-for-speedThe maximum code size growth ratio when expandinginto a jump table (in percent). The parameter is used whenoptimizing for speed.
tree-reassoc-widthSet the maximum number of instructions executed in parallel inreassociated tree. This parameter overrides target dependentheuristics used by default if has non zero value.
sched-pressure-algorithmChoose between the two available implementations of-fsched-pressure. Algorithm 1 is the original implementationand is the more likely to prevent instructions from being reordered.Algorithm 2 was designed to be a compromise between the relativelyconservative approach taken by algorithm 1 and the rather aggressiveapproach taken by the default scheduler. It relies more heavily onhaving a regular register file and accurate register pressure classes.Seehaifa-sched.cc in the GCC sources for more details.
The default choice depends on the target.
max-slsr-cand-scanSet the maximum number of existing candidates that are considered whenseeking a basis for a new straight-line strength reduction candidate.
asan-globalsEnable buffer overflow detection for global objects. This kindof protection is enabled by default if you are using-fsanitize=address option.To disable global objects protection use--param asan-globals=0.
asan-stackEnable buffer overflow detection for stack objects. This kind ofprotection is enabled by default when using-fsanitize=address.To disable stack protection use--param asan-stack=0 option.
asan-instrument-readsEnable buffer overflow detection for memory reads. This kind ofprotection is enabled by default when using-fsanitize=address.To disable memory reads protection use--param asan-instrument-reads=0.
asan-instrument-writesEnable buffer overflow detection for memory writes. This kind ofprotection is enabled by default when using-fsanitize=address.To disable memory writes protection use--param asan-instrument-writes=0 option.
asan-memintrinEnable detection for built-in functions. This kind of protectionis enabled by default when using-fsanitize=address.To disable built-in functions protection use--param asan-memintrin=0.
asan-use-after-returnEnable detection of use-after-return. This kind of protectionis enabled by default when using the-fsanitize=address option.To disable it use--param asan-use-after-return=0.
Note: By default the check is disabled at run time. To enable it,adddetect_stack_use_after_return=1 to the environment variableASAN_OPTIONS.
asan-instrumentation-with-call-thresholdIf number of memory accesses in function being instrumentedis greater or equal to this number, use callbacks instead of inline checks.E.g. to disable inline code use--param asan-instrumentation-with-call-threshold=0.
asan-kernel-mem-intrinsic-prefixIf nonzero, prefix calls tomemcpy,memset andmemmovewith ‘__asan_’ or ‘__hwasan_’for-fsanitize=kernel-address or ‘-fsanitize=kernel-hwaddress’,respectively.
hwasan-instrument-stackEnable hwasan instrumentation of statically sized stack-allocated variables.This kind of instrumentation is enabled by default when using-fsanitize=hwaddress and disabled by default when using-fsanitize=kernel-hwaddress.To disable stack instrumentation use--param hwasan-instrument-stack=0, and to enable it use--param hwasan-instrument-stack=1.
hwasan-random-frame-tagWhen using stack instrumentation, decide tags for stack variables using adeterministic sequence beginning at a random tag for each frame. With thisparameter unset tags are chosen using the same sequence but beginning from 1.This is enabled by default for-fsanitize=hwaddress and unavailablefor-fsanitize=kernel-hwaddress.To disable it use--param hwasan-random-frame-tag=0.
hwasan-instrument-allocasEnable hwasan instrumentation of dynamically sized stack-allocated variables.This kind of instrumentation is enabled by default when using-fsanitize=hwaddress and disabled by default when using-fsanitize=kernel-hwaddress.To disable instrumentation of such variables use--param hwasan-instrument-allocas=0, and to enable it use--param hwasan-instrument-allocas=1.
hwasan-instrument-readsEnable hwasan checks on memory reads. Instrumentation of reads is enabled bydefault for both-fsanitize=hwaddress and-fsanitize=kernel-hwaddress.To disable checking memory reads use--param hwasan-instrument-reads=0.
hwasan-instrument-writesEnable hwasan checks on memory writes. Instrumentation of writes is enabled bydefault for both-fsanitize=hwaddress and-fsanitize=kernel-hwaddress.To disable checking memory writes use--param hwasan-instrument-writes=0.
hwasan-instrument-mem-intrinsicsEnable hwasan instrumentation of builtin functions. Instrumentation of thesebuiltin functions is enabled by default for both-fsanitize=hwaddressand-fsanitize=kernel-hwaddress.To disable instrumentation of builtin functions use--param hwasan-instrument-mem-intrinsics=0.
use-after-scope-direct-emission-thresholdIf the size of a local variable in bytes is smaller or equal to thisnumber, directly poison (or unpoison) shadow memory instead of usingrun-time callbacks.
tsan-distinguish-volatileEmit special instrumentation for accesses to volatiles.
tsan-instrument-func-entry-exitEmit instrumentation calls to __tsan_func_entry() and __tsan_func_exit().
max-fsm-thread-path-insnsMaximum number of instructions to copy when duplicating blocks on afinite state automaton jump thread path.
threader-debugthreader-debug=[none|all] Enables verbose dumping of the threader solver.
parloops-chunk-sizeChunk size of omp schedule for loops parallelized by parloops.
parloops-scheduleSchedule type of omp schedule for loops parallelized by parloops (static,dynamic, guided, auto, runtime).
parloops-min-per-threadThe minimum number of iterations per thread of an innermost parallelizedloop for which the parallelized variant is preferred over the single threadedone. Note that for a parallelized loop nest theminimum number of iterations of the outermost loop per thread is two.
max-ssa-name-query-depthMaximum depth of recursion when querying properties of SSA names in thingslike fold routines. One level of recursion corresponds to following ause-def chain.
max-speculative-devirt-maydefsThe maximum number of may-defs we analyze when looking for a must-defspecifying the dynamic type of an object that invokes a virtual callwe may be able to devirtualize speculatively.
ranger-debugSpecifies the type of debug output to be issued for ranges.
unroll-jam-min-percentThe minimum percentage of memory references that must be optimizedaway for the unroll-and-jam transformation to be considered profitable.
unroll-jam-max-unrollThe maximum number of times the outer loop should be unrolled bythe unroll-and-jam transformation.
max-rtl-if-conversion-unpredictable-costMaximum permissible cost for the sequence that would be generatedby the RTL if-conversion pass for a branch that is considered unpredictable.
max-variable-expansions-in-unrollerIf-fvariable-expansion-in-unroller is used, the maximum numberof times that an individual variable will be expanded during loop unrolling.
partial-inlining-entry-probabilityMaximum probability of the entry BB of split region(in percent relative to entry BB of the function)to make partial inlining happen.
max-tracked-strlensMaximum number of strings for which strlen optimization pass willtrack string lengths.
gcse-after-reload-partial-fractionThe threshold ratio for performing partial redundancyelimination after reload.
gcse-after-reload-critical-fractionThe threshold ratio of critical edges execution count thatpermit performing redundancy elimination after reload.
max-loop-header-insnsThe maximum number of insns in loop header duplicatedby the copy loop headers pass.
vect-epilogues-nomaskEnable loop epilogue vectorization using smaller vector size.
vect-partial-vector-usageControls when the loop vectorizer considers using partial vector loadsand stores as an alternative to falling back to scalar code. 0 stopsthe vectorizer from ever using partial vector loads and stores. 1 allowspartial vector loads and stores if vectorization removes the need for thecode to iterate. 2 allows partial vector loads and stores in all loops.The parameter only has an effect on targets that support partialvector loads and stores.
vect-inner-loop-cost-factorThe maximum factor which the loop vectorizer applies to the cost of statementsin an inner loop relative to the loop being vectorized. The factor appliedis the maximum of the estimated number of iterations of the inner loop andthis parameter. The default value of this parameter is 50.
vect-induction-floatEnable loop vectorization of floating point inductions.
vect-scalar-cost-multiplierApply the given multiplier % to scalar loop costing during vectorization.Increasing the cost multiplier will make vector loops more profitable.
vrp-block-limitMaximum number of basic blocks before VRP switches to a lower memory algorithm.
vrp-sparse-thresholdMaximum number of basic blocks before VRP uses a sparse bitmap cache.
vrp-switch-limitMaximum number of outgoing edges in a switch before VRP will not process it.
vrp-vector-thresholdMaximum number of basic blocks for VRP to use a basic cache vector.
avoid-fma-max-bitsMaximum number of bits for which we avoid creating FMAs.
fully-pipelined-fmaWhether the target fully pipelines FMA instructions. If non-zero,reassociation considers the benefit of parallelizing FMA’s multiplicationpart and addition part, assuming FMUL and FMA use the same units that canalso do FADD.
sms-loop-average-count-thresholdA threshold on the average loop count considered by the swing modulo scheduler.
sms-dfa-historyThe number of cycles the swing modulo scheduler considers when checkingconflicts using DFA.
graphite-allow-codegen-errorsWhether codegen errors should be ICEs when-fchecking.
sms-max-ii-factorA factor for tuning the upper bound that swing modulo scheduleruses for scheduling a loop.
lra-max-considered-reload-pseudosThe max number of reload pseudos which are considered duringspilling a non-reload pseudo.
max-pow-sqrt-depthMaximum depth of sqrt chains to use when synthesizing exponentiationby a real constant.
max-dse-active-local-storesMaximum number of active local stores in RTL dead store elimination.
asan-instrument-allocasEnable asan allocas/VLAs protection.
max-iterations-computation-costBound on the cost of an expression to compute the number of iterations.
max-isl-operationsMaximum number of isl operations, 0 means unlimited.
graphite-max-arrays-per-scopMaximum number of arrays per scop.
max-vartrack-reverse-op-sizeMax. size of loc list for which reverse ops should be added.
fsm-scale-path-stmtsScale factor to apply to the number of statements in a threading pathcrossing a loop backedge when comparing to--param=max-jump-thread-duplication-stmts.
uninit-control-dep-attemptsMaximum number of nested calls to search for control dependenciesduring uninitialized variable analysis.
uninit-max-chain-lenMaximum number of predicates anded for each predicate ored in the normalizedpredicate chain.
uninit-max-num-chainsMaximum number of predicates ored in the normalized predicate chain.
uninit-max-prune-workMaximum amount of work done to prune paths where the variable is always initialized.
sched-autopref-queue-depthHardware autoprefetcher scheduler model control flag.Number of lookahead cycles the model looks into; at ’’ only enable instruction sorting heuristic.
loop-versioning-max-inner-insnsThe maximum number of instructions that an inner loop can havebefore the loop versioning pass considers it too big to copy.
loop-versioning-max-outer-insnsThe maximum number of instructions that an outer loop can havebefore the loop versioning pass considers it too big to copy,discounting any instructions in inner loops that directly benefitfrom versioning.
ssa-name-def-chain-limitThe maximum number of SSA_NAME assignments to follow in determininga property of a variable such as its value. This limits the numberof iterations or recursive calls GCC performs when optimizing certainstatements or when determining their validity prior to issuingdiagnostics.
store-merging-max-sizeMaximum size of a single store merging region in bytes.
store-forwarding-max-distanceMaximum number of instruction distance that a small store forwarded to a largerload may stall. Value ’0’ disables the cost checks for theavoid-store-forwarding pass.
hash-table-verification-limitThe number of elements for which hash table verification is donefor each searched element.
max-find-base-term-valuesMaximum number of VALUEs handled during a single find_base_term call.
analyzer-max-enodes-per-program-pointThe maximum number of exploded nodes per program point withinthe analyzer, before terminating analysis of that point.
analyzer-max-constraintsThe maximum number of constraints per state.
analyzer-min-snodes-for-call-summaryThe minimum number of supernodes within a function for theanalyzer to consider summarizing its effects at call sites.
analyzer-max-enodes-for-full-dumpThe maximum depth of exploded nodes that should appear in a dot dumpbefore switching to a less verbose format.
analyzer-max-recursion-depthThe maximum number of times a callsite can appear in a call stackwithin the analyzer, before terminating analysis of a call that wouldrecurse deeper.
analyzer-max-svalue-depthThe maximum depth of a symbolic value, before approximatingthe value as unknown.
analyzer-max-infeasible-edgesThe maximum number of infeasible edges to reject before declaringa diagnostic as infeasible.
gimple-fe-computed-hot-bb-thresholdThe number of executions of a basic block which is considered hot.The parameter is used only in GIMPLE FE.
analyzer-bb-explosion-factorThe maximum number of ’after supernode’ exploded nodes within the analyzerper supernode, before terminating analysis.
analyzer-text-art-string-ellipsis-thresholdThe number of bytes at which to ellipsize string literals in analyzer text art diagrams.
analyzer-text-art-ideal-canvas-widthThe ideal width in characters of text art diagrams generated by the analyzer.
analyzer-text-art-string-ellipsis-head-lenThe number of literal bytes to show at the head of a string literal in text art when ellipsizing it.
analyzer-text-art-string-ellipsis-tail-lenThe number of literal bytes to show at the tail of a string literal in text art when ellipsizing it.
ranger-logical-depthMaximum depth of logical expression evaluation ranger will look throughwhen evaluating outgoing edge ranges.
ranger-recompute-depthMaximum depth of instruction chains to consider for recomputationin the outgoing range calculator.
relation-block-limitMaximum number of relations the oracle will register in a basic block.
transitive-relations-work-boundWork bound when discovering transitive relations from existing relations.
min-pagesizeMinimum page size for warning and early break vectorization purposes.
openacc-kernelsSpecify mode of OpenACC ‘kernels’ constructs handling.With--param=openacc-kernels=decompose, OpenACC ‘kernels’constructs are decomposed into parts, a sequence of computeconstructs, each then handled individually.This is work in progress.With--param=openacc-kernels=parloops, OpenACC ‘kernels’constructs are handled by the ‘parloops’ pass, en bloc.This is the current default.
openacc-privatizationControl whether the-fopt-info-omp-note and applicable-fdump-tree-*-details options emit OpenACC privatization diagnostics.With--param=openacc-privatization=quiet, don’t diagnose.This is the current default.With--param=openacc-privatization=noisy, do diagnose.
cycle-accurate-modelSpecifies whether GCC should assume that the scheduling description is mostlya cycle-accurate model of the target processor the code is intended torun on, in the absence of cache misses. Nonzero means that the selectedscheduling model is accurate and likely describes an in-order processor,and that scheduling should aggressively spill to try and fill any pipelinebubbles. This is the current default. Zero means the scheduling descriptionmight not be available/accurate or perhaps not applicable at all, such as formodern out-of-order processors.
The following choices ofname are available on AArch64 targets:
aarch64-vect-compare-costsWhen vectorizing, consider using multiple different approaches and usethe cost model to choose the cheapest one. This includes:
aarch64-float-recp-precisionThe number of Newton iterations for calculating the reciprocal for float type.The precision of division is proportional to this param when divisionapproximation is enabled. The default value is 1.
aarch64-double-recp-precisionThe number of Newton iterations for calculating the reciprocal for double type.The precision of division is proportional to this param when divisionapproximation is enabled. The default value is 2.
aarch64-autovec-preferenceAn old alias for-mautovec-preference. If both-mautovec-preference and--param=aarch64-autovec-preferenceare passed, the--param value will be used.
aarch64-ldp-policyFine-grained policy for load pairs.With--param=aarch64-ldp-policy=default, use the policy of thetuning structure. This is the current default.With--param=aarch64-ldp-policy=always, emit ldp regardlessof alignment.With--param=aarch64-ldp-policy=never, do not emit ldp.With--param=aarch64-ldp-policy=aligned, emit ldp only if thesource pointer is aligned to at least double the alignment of the type.
aarch64-stp-policyFine-grained policy for store pairs.With--param=aarch64-stp-policy=default, use the policy of thetuning structure. This is the current default.With--param=aarch64-stp-policy=always, emit stp regardlessof alignment.With--param=aarch64-stp-policy=never, do not emit stp.With--param=aarch64-stp-policy=aligned, emit stp only if thesource pointer is aligned to at least double the alignment of the type.
aarch64-ldp-alias-check-limitLimit on the number of alias checks performed by the AArch64 load/store pairfusion pass when attempting to form an ldp/stp. Higher values make the passmore aggressive at re-ordering loads over stores, at the expense of increasedcompile time.
aarch64-ldp-writebackParam to control which writeback opportunities we try to handle in the AArch64load/store pair fusion pass. A value of zero disables writeback handling. Onemeans we try to form pairs involving one or more existing individual writebackaccesses where possible. A value of two means we also try to opportunisticallyform writeback opportunities by folding in trailing destructive updates of thebase register used by a pair.
aarch64-loop-vect-issue-rate-nitersThe tuning for some AArch64 CPUs tries to take both latencies and issuerates into account when deciding whether a loop should be vectorizedusing SVE, vectorized using Advanced SIMD, or not vectorized at all.If this parameter is set ton, GCC will not use this heuristicfor loops that are known to execute in fewer thann AdvancedSIMD iterations.
aarch64-vect-unroll-limitThe vectorizer will use available tuning information to determine whether itwould be beneficial to unroll the main vectorized loop and by how much. Thisparameter set’s the upper bound of how much the vectorizer will unroll the mainloop. The default value is four.
The following choices ofname are available on GCN targets:
gcn-preferred-vectorization-factorPreferred vectorization factor: ‘default’, ‘32’, ‘64’.
The following choices ofname are available on i386 and x86_64 targets:
x86-stlf-window-ninsnsInstructions number above which STFL stall penalty can be compensated.
x86-stv-max-visitsThe maximum number of use and def visits when discovering a STV chain beforethe discovery is aborted.
ix86-vect-unroll-limitLimit how much the autovectorizer may unroll a loop.
Next:Program Instrumentation Options, Previous:Options for Debugging Your Program, Up:GCC Command Options [Contents][Index]