Next: Preprocessor Options, Previous: Debugging Options, Up: Invoking GCC
These options control various sorts of optimizations.
Without any optimization option, the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.
Turning on optimization flags makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program.
The compiler performs optimization based on the knowledge it has of the program. Optimization levels -O2 and above, in particular, enable unit-at-a-time mode, which allows the compiler to consider information gained from later functions in the file when compiling a function. Compiling multiple files at once to a single output file in unit-at-a-time mode allows the compiler to use information gained from all of the files when compiling each of them.
Not all optimizations are controlled directly by a flag. Only optimizations that have a flag are listed.
-O-O1With -O, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time.
-O turns on the following optimization flags:
-fdefer-pop
-fdelayed-branch
-fguess-branch-probability
-fcprop-registers
-floop-optimize
-fif-conversion
-fif-conversion2
-ftree-ccp
-ftree-dce
-ftree-dominator-opts
-ftree-dse
-ftree-ter
-ftree-lrs
-ftree-sra
-ftree-copyrename
-ftree-fre
-ftree-ch
-fmerge-constants
-O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging.
-O doesn't turn on -ftree-sra for the Ada compiler.
This option must be explicitly specified on the command line to be
enabled for the Ada compiler.
-O2-O2 turns on all optimization flags specified by -O. It also turns on the following optimization flags:
-fthread-jumps
-fcrossjumping
-foptimize-sibling-calls
-fcse-follow-jumps -fcse-skip-blocks
-fgcse -fgcse-lm
-fexpensive-optimizations
-fstrength-reduce
-frerun-cse-after-loop -frerun-loop-opt
-fcaller-saves
-fforce-mem
-fpeephole2
-fschedule-insns -fschedule-insns2
-fsched-interblock -fsched-spec
-fregmove
-fstrict-aliasing
-fdelete-null-pointer-checks
-freorder-blocks -freorder-functions
-funit-at-a-time
-falign-functions -falign-jumps
-falign-loops -falign-labels
-ftree-pre
Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos.
In Apple's version of GCC, -fstrict-aliasing,
-freorder-blocks, and -fsched-interblock
are disabled by default when optimizing.
-O3-O0-fast-fast currently enables the following optimization flags (for G5 and PPC7450). These flags may change in the future. You cannot override any of these options if you use -fast except by setting -mcpu=7450 (or -fPIC, see below).
-O3
-falign-loops-max-skip=15
-falign-jumps-max-skip=15
-falign-loops=16
-falign-jumps=16
-falign-functions=16
-malign-natural (except when -fastf is specified)
-ffast-math
-fstrict-aliasing
-funroll-loops
-ftree-loop-linear
-ftree-loop-memset
-mcpu=G5
-mpowerpc-gpopt
-mtune=G5 (unless -mtune=G4 is specified).
-fsched-interblock
-fgcse-sm
-mpowerpc64
To build shared libraries with -fast, specify -fPIC on the command line as -fast turns on -mdynamic-no-pic otherwise.
Important notes: -ffast-math results in code that is not necessarily IEEE-compliant. -fstrict-aliasing is highly likely to break non-standard-compliant programs. -malign-natural only works properly if the entire program is compiled with it, and none of the standard headers/libraries contain any code that changes alignment when this option is used.
On Intel target, -fast currently enables the following optimization flags:
-O3
-fomit-frame-pointer
-fstrict-aliasing
-momit-leaf-frame-pointer
-fno-tree-pre
-falign-loops
All choices of flags enabled by -fast are subject to change without notice.
-OsThe following options are set for -O2, but are disabled under -Os:
-falign-functions -falign-jumps -falign-loops
-falign-labels -freorder-blocks -freorder-blocks-and-partition
-fprefetch-loop-arrays
When optimizing with -Os or -Oz (APPLE ONLY) on
Darwin, any function up to 30 “estimated insns” in size will be
considered for inlining. When compiling C and Objective-C sourcefiles with
-Os or -Oz on Darwin, functions explictly marked
with the inline keyword up to 450 “estimated insns” in size
will be considered for inlining.
When compiling for Apple POWERPC targets, -Os and
-Oz (APPLE ONLY) disable use of the string instructions even though they
would usually be smaller, because the kernel can't emulate them
correctly in some rare cases. This behavior is not portable to any
other gcc environment, and will not affect most programs at all. If
you really want the string instructions, use -mstring.
-OzIf you use multiple -O options, with or without level numbers, the last such option is the one that is effective.
Options of the form -fflag specify machine-independent flags. Most flags have both positive and negative forms; the negative form of -ffoo would be -fno-foo. In the table below, only one of the forms is listed—the one you typically will use. You can figure out the other form by either removing `no-' or adding it.
The following options control specific optimizations. They are either activated by -O options or are related to ones that are. You can use the following flags in the rare cases when “fine-tuning” of optimizations to be performed is desired.
-fno-default-inline-fno-defer-popDisabled at levels -O, -O2, -O3, -Os,
-Oz (APPLE ONLY).
-fforce-memEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fforce-addr-fomit-frame-pointerOn some machines, such as the VAX, this flag has no effect, because
the standard calling sequence automatically handles the frame pointer
and nothing is saved by pretending it doesn't exist. The
machine-description macro FRAME_POINTER_REQUIRED controls
whether a target machine supports this flag. See Register Usage.
Enabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-foptimize-sibling-callsEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fno-inlineinline keyword. Normally this option
is used to keep the compiler from expanding any functions inline.
Note that if you are not optimizing, no functions can be expanded inline.
-finline-functionsIf all calls to a given function are integrated, and the function is
declared static, then the function is normally not output as
assembler code in its own right.
Enabled at level -O3.
-finline-limit=nInlining is actually controlled by a number of parameters, which may be specified individually by using --param name=value. The -finline-limit=n option sets some of these parameters as follows:
max-inline-insns-singlemax-inline-insns-automin-inline-insnsmax-inline-insns-rtlSee below for a documentation of the individual parameters controlling inlining.
Note: pseudo instruction represents, in this particular context, an
abstract measurement of function's size. In no way, it represents a count
of assembly instructions and as such its exact meaning might change from one
release to an another.
-fkeep-inline-functionsstatic functions that are declared inline
into the object file, even if the function has been inlined into all
of its callers. This switch does not affect functions using the
extern inline extension in GNU C. In C++, emit any and all
inline functions into the object file.
-fkeep-static-constsstatic const when optimization isn't turned
on, even if the variables aren't referenced.
GCC enables this option by default. If you want to force the compiler to
check if the variable was referenced, regardless of whether or not
optimization is turned on, use the -fno-keep-static-consts option.
-fmerge-constantsThis option is the default for optimized compilation if the assembler and linker support it. Use -fno-merge-constants to inhibit this behavior.
Enabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-fmerge-all-constantsThis option implies -fmerge-constants. In addition to
-fmerge-constants this considers e.g. even constant initialized
arrays or initialized constant variables with integral or floating point
types. Languages like C or C++ require each non-automatic variable to
have distinct location, so using this option will result in non-conforming
behavior.
-fmodulo-sched-fno-branch-count-regThe default is -fbranch-count-reg, enabled when
-fstrength-reduce is enabled.
-fno-function-cseThis option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used.
The default is -ffunction-cse
-fno-zero-initialized-in-bssThis option turns off this behavior because some programs explicitly rely on variables going to the data section. E.g., so that the resulting executable can find the beginning of that section and/or make assumptions based on that.
The default is -fzero-initialized-in-bss.
-fbounds-check-fmudflap -fmudflapth -fmudflapirenv MUDFLAP_OPTIONS=-help a.out
for its options.
Use -fmudflapth instead of -fmudflap to compile and to
link if your program is multi-threaded. Use -fmudflapir, in
addition to -fmudflap or -fmudflapth, if
instrumentation should ignore pointer reads. This produces less
instrumentation (and therefore faster execution) and still provides
some protection against outright memory corrupting writes, but allows
erroneously read data to propagate within a program.
-fstrength-reduceEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fthread-jumpsEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fcse-follow-jumpsif statement with an
else clause, CSE will follow the jump when the condition
tested is false.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fcse-skip-blocksif statement with no else clause,
-fcse-skip-blocks causes CSE to follow the jump around the
body of the if.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-frerun-cse-after-loopEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-frerun-loop-optEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fgcseNote: When compiling a program using computed gotos, a GCC extension, you may get better runtime performance if you disable the global common subexpression elimination pass by adding -fno-gcse to the command line.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fgcse-lmEnabled by default when gcse is enabled.
-fgcse-smNot enabled at any optimization level.
-fgcse-lasNot enabled at any optimization level.
-fgcse-after-reload-floop-optimizeEnabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-floop-optimize2-fcrossjumpingEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fif-conversionif-conversion2.
Enabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-fif-conversion2Enabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-fdelete-null-pointer-checksIn some environments, this assumption is not true, and programs can safely dereference null pointers. Use -fno-delete-null-pointer-checks to disable this optimization for programs which depend on that behavior.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fexpensive-optimizationsEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-foptimize-register-move-fregmoveNote -fregmove and -foptimize-register-move are the same optimization.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fdelayed-branchEnabled at levels -O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-fschedule-insnsEnabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fschedule-insns2Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fno-sched-interblock-fno-sched-spec-fsched-spec-load-fsched-spec-load-dangerous-fsched-stalled-insns=n-fsched-stalled-insns-dep=n-fsched2-use-superblocksThis only makes sense when scheduling after register allocation, i.e. with
-fschedule-insns2 or at -O2 or higher.
-fsched2-use-tracesThis mode should produce faster but significantly longer programs. Also
without -fbranch-probabilities the traces constructed may not
match the reality and hurt the performance. This only makes
sense when scheduling after register allocation, i.e. with
-fschedule-insns2 or at -O2 or higher.
-freschedule-modulo-scheduled-loops-fcaller-savesThis option is always enabled by default on certain machines, usually those which have no call-preserved registers to use instead.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-ftree-pre-ftree-fre-ftree-ccp-ftree-dce-ftree-dominator-opts-ftree-ch-ftree-elim-checks-ftree-loop-optimize-ftree-loop-linear-ftree-loop-im-ftree-loop-ivcanon-fivopts-ftree-sra-ftree-copyrename-ftree-ter-ftree-lrs-ftree-vectorizeIn Apple's version of GCC, -fstrict-aliasing is enabled by default
when loop vectorization is enabled. See -fstrict-aliasing document
for more information.
-ftracer-funroll-loops-funroll-all-loops-fsplit-ivs-in-unrollerCombination of -fweb and CSE is often sufficient to obtain the same effect. However in cases the loop body is more complicated than a single basic block, this is not reliable. It also does not work at all on some of the architectures due to restrictions in the CSE pass.
This optimization is enabled by default.
-fvariable-expansion-in-unroller-fprefetch-loop-arraysThese options may generate better or worse code; results are highly
dependent on the structure of loops within the source code.
-fno-peephole-fno-peephole2-fpeephole is enabled by default.
-fpeephole2 enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fno-guess-branch-probabilityGCC will use heuristics to guess branch probabilities if they are not provided by profiling feedback (-fprofile-arcs). These heuristics are based on the control flow graph. If some branch probabilities are specified by `__builtin_expect', then the heuristics will be used to guess branch probabilities for the rest of the control flow graph, taking the `__builtin_expect' info into account. The interactions between the heuristics and `__builtin_expect' can be complex, and in some cases, it may be useful to disable the heuristics so that the effects of `__builtin_expect' are easier to understand.
The default is -fguess-branch-probability at levels
-O, -O2, -O3, -Os, -Oz (APPLE ONLY).
-freorder-blocksEnabled at levels -O2, -O3.
-freorder-blocks-and-partitionThis optimization is automatically turned off in the presence of
exception handling, for linkonce sections, for functions with a user-defined
section attribute and on any architecture that does not support named
sections.
-freorder-functions.text.hot for most frequently executed functions and
.text.unlikely for unlikely executed functions. Reordering is done by
the linker so object file format must support named sections and linker must
place them in a reasonable way.
Also profile feedback must be available in to make this option effective. See -fprofile-arcs for details.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-fstrict-aliasingunsigned int can alias an int, but not a
void* or a double. A character type may alias any other
type.
Pay special attention to code like this:
union a_union {
int i;
double d;
};
int f() {
a_union t;
t.d = 3.0;
return t.i;
}
The practice of reading from a different union member than the one most recently written to (called “type-punning”) is common. Even with -fstrict-aliasing, type-punning is allowed, provided the memory is accessed through the union type. So, the code above will work as expected. However, this code might not:
int f() {
a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}
Every language that wishes to perform language-specific alias analysis
should define a function that computes, given an tree
node, an alias set for the node. Nodes in different alias sets are not
allowed to alias. For an example, see the C front-end function
c_get_alias_set.
Enabled at levels -O2, -O3, -Os, -Oz (APPLE ONLY).
-falign-functions-falign-functions=n-fno-align-functions and -falign-functions=1 are equivalent and mean that functions will not be aligned.
Some assemblers only support this flag when n is a power of two; in that case, it is rounded up.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-falign-labels-falign-labels=n-fno-align-labels and -falign-labels=1 are equivalent and mean that labels will not be aligned.
If -falign-loops or -falign-jumps are applicable and are greater than this value, then their values are used instead.
If n is not specified or is zero, use a machine-dependent default which is very likely to be `1', meaning no alignment.
Enabled at levels -O2, -O3.
-falign-loops-max-skip-falign-loops-max-skip=n-falign-loops-falign-loops=n-fno-align-loops and -falign-loops=1 are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-falign-jumps-falign-jumps=n-falign-jumps-max-skip-falign-jumps-max-skip=n-fno-align-jumps and -falign-jumps=1 are equivalent and mean that loops will not be aligned.
If n is not specified or is zero, use a machine-dependent default.
Enabled at levels -O2, -O3.
-funit-at-a-timeasm statements
are emitted, and will likely break code relying on some particular
ordering. The majority of such top-level asm statements,
though, can be replaced by section attributes.
asm statement refers directly to variables or functions
that are otherwise unused. In that case either the variable/function
shall be listed as an operand of the asm statement operand or,
in the case of top-level asm statements the attribute used
shall be used on the declaration.
asm statements calling functions directly. Again,
attribute used will prevent this behavior.
As a temporary workaround, -fno-unit-at-a-time can be used, but this scheme may not be supported by future releases of GCC.
Enabled at levels -O2, -O3.
-fwebEnabled by default with -funroll-loops.
-fno-cprop-registersDisabled at levels -O, -O2, -O3, -Os,
-Oz (APPLE ONLY).
-fprofile-generateThe following options are enabled: -fprofile-arcs, -fprofile-values, -fvpt.
-fprofile-useThe following options are enabled: -fbranch-probabilities,
-fvpt, -funroll-loops, -fpeel-loops, -ftracer.
The following options control compiler behavior regarding floating point arithmetic. These options trade off between speed and correctness. All must be specifically enabled.
-ffloat-storeThis option prevents undesirable excess precision on machines such as
the 68000 where the floating registers (of the 68881) keep more
precision than a double is supposed to have. Similarly for the
x86 architecture. For most programs, the excess precision does only
good, but a few programs rely on the precise definition of IEEE floating
point. Use -ffloat-store for such programs, after modifying
them to store all pertinent intermediate computations into variables.
-ffast-mathThis option causes the preprocessor macro __FAST_MATH__ to be defined.
This option should never be turned on by any -O option since
it can result in incorrect output for programs which depend on
an exact implementation of IEEE or ISO rules/specifications for
math functions.
-fno-math-errno(APPLE ONLY) The Darwin math libraries never set errno, so there is
no point in having the compiler generate code that assumes they
might. Therefore, the default is -fno-math-errno on Darwin.
-funsafe-math-optimizationsThis option should never be turned on by any -O option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ISO rules/specifications for math functions.
The default is -fno-unsafe-math-optimizations.
-ffinite-math-onlyThis option should never be turned on by any -O option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ISO rules/specifications.
The default is -fno-finite-math-only.
-fno-trapping-mathThis option should never be turned on by any -O option since it can result in incorrect output for programs which depend on an exact implementation of IEEE or ISO rules/specifications for math functions.
The default is -ftrapping-math.
-frounding-mathThe default is -fno-rounding-math.
This option is experimental and does not currently guarantee to
disable all GCC optimizations that are affected by rounding mode.
Future versions of GCC may provide finer control of this setting
using C99's FENV_ACCESS pragma. This command line option
will be used to specify the default state for FENV_ACCESS.
-fsignaling-nansThis option causes the preprocessor macro __SUPPORT_SNAN__ to
be defined.
The default is -fno-signaling-nans.
This option is experimental and does not currently guarantee to
disable all GCC optimizations that affect signaling NaN behavior.
-fsingle-precision-constant-fcx-limited-range-fno-cx-limited-rangeThis option controls the default setting of the ISO C99
CX_LIMITED_RANGE pragma. Nevertheless, the option applies to
all languages.
The following options control optimizations that may improve performance, but are not enabled by any -O options. This section includes experimental options that may produce broken code.
-fbranch-probabilitiesWith -fbranch-probabilities, GCC puts a
`REG_BR_PROB' note on each `JUMP_INSN' and `CALL_INSN'.
These can be used to improve optimization. Currently, they are only
used in one place: in reorg.c, instead of guessing which path a
branch is mostly to take, the `REG_BR_PROB' values are used to
exactly determine which path is taken more often.
-fprofile-valuesWith -fbranch-probabilities, it reads back the data gathered from profiling values of expressions and adds `REG_VALUE_PROFILE' notes to instructions for their later usage in optimizations.
Enabled with -fprofile-generate and -fprofile-use.
-fvptWith -fbranch-probabilities, it reads back the data gathered
and actually performs the optimizations based on them.
Currently the optimizations include specialization of division operation
using the knowledge about the value of the denominator.
-fspeculative-prefetchingWith -fbranch-probabilities, it reads back the data gathered and issues prefetch instructions according to them. In addition to the opportunities noticed by -fprefetch-loop-arrays, it also notices more complicated memory access patterns—for example accesses to the data stored in linked list whose elements are usually allocated sequentially.
In order to prevent issuing double prefetches, usage of -fspeculative-prefetching implies -fno-prefetch-loop-arrays.
Enabled with -fprofile-generate and -fprofile-use.
-frename-registersNot enabled by default at any level because it has known bugs.
-ftracerEnabled with -fprofile-use.
-funroll-loopsEnabled with -fprofile-use.
-funroll-all-loops-fpeel-loopsEnabled with -fprofile-use.
-fmove-loop-invariants-funswitch-loops-fprefetch-loop-arraysDisabled at levels -Os and -Oz (APPLE ONLY).
-ffunction-sections-fdata-sectionsUse these options on systems where the linker can perform optimizations to improve locality of reference in the instruction space. Most systems using the ELF object format and SPARC processors running Solaris 2 have linkers with such optimizations. AIX may have these optimizations in the future.
Only use these options when there are significant benefits from doing
so. When you specify these options, the assembler and linker will
create larger object and executable files and will also be slower.
You will not be able to use gprof on all systems if you
specify this option and you may have problems with debugging if
you specify both this option and -g.
-fbranch-target-load-optimize-fbranch-target-load-optimize2-fbtr-bb-exclusive-fstack-protector-fstack-protector-all--param name=valueThe names of specific parameters, and the meaning of the values, are tied to the internals of the compiler, and are subject to change without notice in future releases.
In each case, the value is an integer. The allowable choices for name are given in the following table:
sra-max-structure-sizesra-field-structure-ratiomax-crossjump-edgesmin-crossjump-insnsmax-goto-duplication-insnsmax-delay-slot-insn-searchmax-delay-slot-live-searchmax-gcse-memorymax-gcse-passesmax-pending-list-lengthmax-inline-insns-singlemax-inline-insns-autolarge-function-insnslarge-function-growthinline-unit-growthmax-inline-insns-recursivemax-inline-insns-recursive-autoFor functions declared inline --param max-inline-insns-recursive is
taken into acount. For function not declared inline, recursive inlining
happens only when -finline-functions (included in -O3) is
enabled and --param max-inline-insns-recursive-auto is used. The
default value is 450.
max-inline-recursive-depthmax-inline-recursive-depth-autoFor functions declared inline --param max-inline-recursive-depth is
taken into acount. For function not declared inline, recursive inlining
happens only when -finline-functions (included in -O3) is
enabled and --param max-inline-recursive-depth-auto is used. The
default value is 450.
inline-call-costmax-unrolled-insnsmax-average-unrolled-insnsmax-unroll-timesmax-peeled-insnsmax-peel-timesmax-completely-peeled-insnsmax-completely-peel-timesmax-unswitch-insnsmax-unswitch-levellim-expensiveiv-consider-all-candidates-boundiv-max-considered-usesiv-always-prune-cand-set-boundscev-max-expr-sizemax-iterations-to-trackhot-bb-count-fractionhot-bb-frequency-fractiontracer-dynamic-coveragetracer-dynamic-coverage-feedbackThe tracer-dynamic-coverage-feedback is used only when profile
feedback is available. The real profiles (as opposed to statically estimated
ones) are much less balanced allowing the threshold to be larger value.
tracer-max-code-growthtracer-min-branch-ratiotracer-min-branch-ratiotracer-min-branch-ratio-feedbackSimilarly to tracer-dynamic-coverage two values are present, one for
compilation for profile feedback and one for compilation without. The value
for compilation with profile feedback needs to be more conservative (higher) in
order to make tracer effective.
max-cse-path-lengthglobal-var-thresholdint * size_t on the host machine; beware overflow).
max-aliased-vopsggc-min-expandThe default is 30% + 70% * (RAM/1GB) with an upper bound of 100% when
RAM >= 1GB. If getrlimit is available, the notion of "RAM" is
the smallest of actual RAM and RLIMIT_DATA or RLIMIT_AS. If
GCC is not able to calculate RAM on a particular platform, the lower
bound of 30% is used. Setting this parameter and
ggc-min-heapsize to zero causes a full collection to occur at
every opportunity. This is extremely slow, but can be useful for
debugging.
ggc-min-heapsizeThe default is the smaller of RAM/8, RLIMIT_RSS, or a limit which
tries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, but
with a lower bound of 4096 (four megabytes) and an upper bound of
131072 (128 megabytes). If GCC is not able to calculate RAM on a
particular platform, the lower bound is used. Setting this parameter
very large effectively disables garbage collection. Setting this
parameter and ggc-min-expand to zero causes a full collection
to occur at every opportunity.
max-reload-search-insnsmax-cselib-memory-locationreorder-blocks-duplicatereorder-blocks-duplicate-feedbackThe reorder-block-duplicate-feedback is used only when profile
feedback is available and may be set to higher values than
reorder-block-duplicate since information about the hot spots is more
accurate.
max-sched-region-blocksmax-sched-region-insnsmax-last-value-rtlinteger-share-limitssp-buffer-size