optimize-options.html

自己收集的linux入门到学懂高级编程书集 包括linux程序设计第三版

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 <code>gprof</code> on all systems if you
specify this option and you may have problems with debugging if
you specify both this option and <code>-g</code>.

     <br><dt><code>-fbranch-target-load-optimize</code>
     <dd>Perform branch target register load optimization before prologue / epilogue
threading. 
The use of target registers can typically be exposed only during reload,
thus hoisting loads out of loops and doing inter-block scheduling needs
a separate optimization pass.

     <br><dt><code>-fbranch-target-load-optimize2</code>
     <dd>Perform branch target register load optimization after prologue / epilogue
threading.

     <br><dt><code>-fbtr-bb-exclusive</code>
     <dd>When performing branch target register load optimization, don't reuse
branch target registers in within any basic block.

     <br><dt><code>--param </code><var>name</var><code>=</code><var>value</var><code></code>
     <dd>In some places, GCC uses various constants to control the amount of
optimization that is done.  For example, GCC will not inline functions
that contain more that a certain number of instructions.  You can
control some of these constants on the command-line using the
<code>--param</code> option.

     <p>The names of specific parameters, and the meaning of the values, are
tied to the internals of the compiler, and are subject to change
without notice in future releases.

     <p>In each case, the <var>value</var> is an integer.  The allowable choices for
<var>name</var> are given in the following table:

          <dl>
<dt><code>max-crossjump-edges</code>
          <dd>The maximum number of incoming edges to consider for crossjumping. 
The algorithm used by <code>-fcrossjumping</code> is O(N^2) in
the number of edges incoming to each block.  Increasing values mean
more aggressive optimization, making the compile time increase with
probably small improvement in executable size.

          <br><dt><code>max-delay-slot-insn-search</code>
          <dd>The maximum number of instructions to consider when looking for an
instruction to fill a delay slot.  If more than this arbitrary number of
instructions is searched, the time savings from filling the delay slot
will be minimal so stop searching.  Increasing values mean more
aggressive optimization, making the compile time increase with probably
small improvement in executable run time.

          <br><dt><code>max-delay-slot-live-search</code>
          <dd>When trying to fill delay slots, the maximum number of instructions to
consider when searching for a block with valid live register
information.  Increasing this arbitrarily chosen value means more
aggressive optimization, increasing the compile time.  This parameter
should be removed when the delay slot code is rewritten to maintain the
control-flow graph.

          <br><dt><code>max-gcse-memory</code>
          <dd>The approximate maximum amount of memory that will be allocated in
order to perform the global common subexpression elimination
optimization.  If more memory than specified is required, the
optimization will not be done.

          <br><dt><code>max-gcse-passes</code>
          <dd>The maximum number of passes of GCSE to run.  The default is 1.

          <br><dt><code>max-pending-list-length</code>
          <dd>The maximum number of pending dependencies scheduling will allow
before flushing the current state and starting over.  Large functions
with few branches or calls can create excessively large lists which
needlessly consume memory and resources.

          <br><dt><code>max-inline-insns-single</code>
          <dd>Several parameters control the tree inliner used in gcc. 
This number sets the maximum number of instructions (counted in GCC's
internal representation) in a single function that the tree inliner
will consider for inlining.  This only affects functions declared
inline and methods implemented in a class declaration (C++). 
The default value is 500.

          <br><dt><code>max-inline-insns-auto</code>
          <dd>When you use <code>-finline-functions</code> (included in <code>-O3</code>),
a lot of functions that would otherwise not be considered for inlining
by the compiler will be investigated.  To those functions, a different
(more restrictive) limit compared to functions declared inline can
be applied. 
The default value is 120.

          <br><dt><code>large-function-insns</code>
          <dd>The limit specifying really large functions.  For functions greater than this
limit inlining is constrained by <code>--param large-function-growth</code>. 
This parameter is useful primarily to avoid extreme compilation time caused by non-linear
algorithms used by the backend. 
This parameter is ignored when <code>-funit-at-a-time</code> is not used. 
The default value is 3000.

          <br><dt><code>large-function-growth</code>
          <dd>Specifies maximal growth of large function caused by inlining in percents. 
This parameter is ignored when <code>-funit-at-a-time</code> is not used. 
The default value is 200.

          <br><dt><code>inline-unit-growth</code>
          <dd>Specifies maximal overall growth of the compilation unit caused by inlining. 
This parameter is ignored when <code>-funit-at-a-time</code> is not used. 
The default value is 150.

          <br><dt><code>max-inline-insns-rtl</code>
          <dd>For languages that use the RTL inliner (this happens at a later stage
than tree inlining), you can set the maximum allowable size (counted
in RTL instructions) for the RTL inliner with this parameter. 
The default value is 600.

          <br><dt><code>max-unrolled-insns</code>
          <dd>The maximum number of instructions that a loop should have if that loop
is unrolled, and if the loop is unrolled, it determines how many times
the loop code is unrolled.

          <br><dt><code>max-average-unrolled-insns</code>
          <dd>The maximum number of instructions biased by probabilities of their execution
that a loop should have if that loop is unrolled, and if the loop is unrolled,
it determines how many times the loop code is unrolled.

          <br><dt><code>max-unroll-times</code>
          <dd>The maximum number of unrollings of a single loop.

          <br><dt><code>max-peeled-insns</code>
          <dd>The maximum number of instructions that a loop should have if that loop
is peeled, and if the loop is peeled, it determines how many times
the loop code is peeled.

          <br><dt><code>max-peel-times</code>
          <dd>The maximum number of peelings of a single loop.

          <br><dt><code>max-completely-peeled-insns</code>
          <dd>The maximum number of insns of a completely peeled loop.

          <br><dt><code>max-completely-peel-times</code>
          <dd>The maximum number of iterations of a loop to be suitable for complete peeling.

          <br><dt><code>max-unswitch-insns</code>
          <dd>The maximum number of insns of an unswitched loop.

          <br><dt><code>max-unswitch-level</code>
          <dd>The maximum number of branches unswitched in a single loop.

          <br><dt><code>hot-bb-count-fraction</code>
          <dd>Select fraction of the maximal count of repetitions of basic block in program
given basic block needs to have to be considered hot.

          <br><dt><code>hot-bb-frequency-fraction</code>
          <dd>Select fraction of the maximal frequency of executions of basic block in
function given basic block needs to have to be considered hot

          <br><dt><code>tracer-dynamic-coverage</code>
          <dd><dt><code>tracer-dynamic-coverage-feedback</code>
          <dd>
This value is used to limit superblock formation once the given percentage of
executed instructions is covered.  This limits unnecessary code size
expansion.

          <p>The <code>tracer-dynamic-coverage-feedback</code> 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.

          <br><dt><code>tracer-max-code-growth</code>
          <dd>Stop tail duplication once code growth has reached given percentage.  This is
rather hokey argument, as most of the duplicates will be eliminated later in
cross jumping, so it may be set to much higher values than is the desired code
growth.

          <br><dt><code>tracer-min-branch-ratio</code>
          <dd>
Stop reverse growth when the reverse probability of best edge is less than this
threshold (in percent).

          <br><dt><code>tracer-min-branch-ratio</code>
          <dd><dt><code>tracer-min-branch-ratio-feedback</code>
          <dd>
Stop forward growth if the best edge do have probability lower than this
threshold.

          <p>Similarly to <code>tracer-dynamic-coverage</code> 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.

          <br><dt><code>max-cse-path-length</code>
          <dd>
Maximum number of basic blocks on path that cse considers.  The default is 10.

          <br><dt><code>ggc-min-expand</code>
          <dd>
GCC uses a garbage collector to manage its own memory allocation.  This
parameter specifies the minimum percentage by which the garbage
collector's heap should be allowed to expand between collections. 
Tuning this may improve compilation speed; it has no effect on code
generation.

          <p>The default is 30% + 70% * (RAM/1GB) with an upper bound of 100% when
RAM &gt;= 1GB.  If <code>getrlimit</code> is available, the notion of "RAM" is
the smallest of actual RAM, RLIMIT_RSS, RLIMIT_DATA and 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
<code>ggc-min-heapsize</code> to zero causes a full collection to occur at
every opportunity.  This is extremely slow, but can be useful for
debugging.

          <br><dt><code>ggc-min-heapsize</code>
          <dd>
Minimum size of the garbage collector's heap before it begins bothering
to collect garbage.  The first collection occurs after the heap expands
by <code>ggc-min-expand</code>% beyond <code>ggc-min-heapsize</code>.  Again,
tuning this may improve compilation speed, and has no effect on code
generation.

          <p>The default is RAM/8, with a lower bound of 4096 (four megabytes) and an
upper bound of 131072 (128 megabytes).  If <code>getrlimit</code> is
available, the notion of "RAM" is the smallest of actual RAM,
RLIMIT_RSS, RLIMIT_DATA and RLIMIT_AS.  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 <code>ggc-min-expand</code> to zero causes a full
collection to occur at every opportunity.

          <br><dt><code>max-reload-search-insns</code>
          <dd>The maximum number of instruction reload should look backward for equivalent
register.  Increasing values mean more aggressive optimization, making the
compile time increase with probably slightly better performance.  The default
value is 100.

          <br><dt><code>max-cselib-memory-location</code>
          <dd>The maximum number of memory locations cselib should take into acount. 
Increasing values mean more aggressive optimization, making the compile time
increase with probably slightly better performance.  The default value is 500.

          <br><dt><code>reorder-blocks-duplicate</code>
          <dd><dt><code>reorder-blocks-duplicate-feedback</code>
          <dd>
Used by basic block reordering pass to decide whether to use unconditional
branch or duplicate the code on its destination.  Code is duplicated when its
estimated size is smaller than this value multiplied by the estimated size of
unconditional jump in the hot spots of the program.

          <p>The <code>reorder-block-duplicate-feedback</code> is used only when profile
feedback is available and may be set to higher values than
<code>reorder-block-duplicate</code> since information about the hot spots is more
accurate.

          <br><dt><code>max-sched-region-blocks</code>
          <dd>The maximum number of blocks in a region to be considered for
interblock scheduling.  The default value is 10.

          <br><dt><code>max-sched-region-insns</code>
          <dd>The maximum number of insns in a region to be considered for
interblock scheduling.  The default value is 100. 
</dl>
     </dl>

   </body></html>