mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-24 11:29:10 +00:00
282 lines
11 KiB
Modula-2
282 lines
11 KiB
Modula-2
/* params.def - Run-time parameters.
|
|
Copyright (C) 2001, 2002 Free Software Foundation, Inc.
|
|
Written by Mark Mitchell <mark@codesourcery.com>.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 2, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
02111-1307, USA.
|
|
|
|
*/
|
|
|
|
/* This file contains definitions for language-independent
|
|
parameters. The DEFPARAM macro takes 4 arguments:
|
|
|
|
- The enumeral corresponding to this parameter.
|
|
|
|
- The name that can be used to set this parameter using the
|
|
command-line option `--param <name>=<value>'.
|
|
|
|
- A help string explaining how the parameter is used.
|
|
|
|
- A default value for the parameter.
|
|
|
|
Be sure to add an entry to invoke.texi summarizing the parameter. */
|
|
|
|
/* The single function inlining limit. This is the maximum size
|
|
of a function counted in internal gcc instructions (not in
|
|
real machine instructions) that is eligible for inlining
|
|
by the tree inliner.
|
|
The default value is 500.
|
|
Only functions marked inline (or methods defined in the class
|
|
definition for C++) are affected by this, unless you set the
|
|
-finline-functions (included in -O3) compiler option.
|
|
There are more restrictions to inlining: If inlined functions
|
|
call other functions, the already inlined instructions are
|
|
counted and once the recursive inline limit (see
|
|
"max-inline-insns" parameter) is exceeded, the acceptable size
|
|
gets decreased. */
|
|
DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
|
|
"max-inline-insns-single",
|
|
"The maximum number of instructions in a single function eligible for inlining",
|
|
500)
|
|
|
|
/* The single function inlining limit for functions that are
|
|
inlined by virtue of -finline-functions (-O3).
|
|
This limit should be chosen to be below or equal to the limit
|
|
that is applied to functions marked inlined (or defined in the
|
|
class declaration in C++) given by the "max-inline-insns-single"
|
|
parameter.
|
|
The default value is 150. */
|
|
DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
|
|
"max-inline-insns-auto",
|
|
"The maximum number of instructions when automatically inlining",
|
|
100)
|
|
|
|
/* For languages that (still) use the RTL inliner, we can specify
|
|
limits for the RTL inliner separately.
|
|
The parameter here defines the maximum number of RTL instructions
|
|
a function may have to be eligible for inlining in the RTL inliner.
|
|
The default value is 600. */
|
|
DEFPARAM (PARAM_MAX_INLINE_INSNS_RTL,
|
|
"max-inline-insns-rtl",
|
|
"The maximum number of instructions for the RTL inliner",
|
|
600)
|
|
|
|
/* 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. */
|
|
DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH,
|
|
"max-delay-slot-insn-search",
|
|
"The maximum number of instructions to consider to fill a delay slot",
|
|
100)
|
|
|
|
/* 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. */
|
|
DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH,
|
|
"max-delay-slot-live-search",
|
|
"The maximum number of instructions to consider to find accurate live register information",
|
|
333)
|
|
|
|
/* This parameter limits the number of branch elements that the
|
|
scheduler will track anti-dependencies through without resetting
|
|
the tracking mechanism. Large functions with few calls or barriers
|
|
can generate lists containing many 1000's of dependencies. Generally
|
|
the compiler either uses all available memory, or runs for far too long. */
|
|
DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH,
|
|
"max-pending-list-length",
|
|
"The maximum length of scheduling's pending operations list",
|
|
32)
|
|
|
|
DEFPARAM(PARAM_LARGE_FUNCTION_INSNS,
|
|
"large-function-insns",
|
|
"The size of function body to be considered large",
|
|
3000)
|
|
DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH,
|
|
"large-function-growth",
|
|
"Maximal growth due to inlining of large function (in percent)",
|
|
100)
|
|
DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
|
|
"inline-unit-growth",
|
|
"how much can given compilation unit grow because of the inlining (in percent)",
|
|
50)
|
|
|
|
/* The GCSE optimization will be disabled if it would require
|
|
significantly more memory than this value. */
|
|
DEFPARAM(PARAM_MAX_GCSE_MEMORY,
|
|
"max-gcse-memory",
|
|
"The maximum amount of memory to be allocated by GCSE",
|
|
50 * 1024 * 1024)
|
|
/* The number of repetitions of copy/const prop and PRE to run. */
|
|
DEFPARAM(PARAM_MAX_GCSE_PASSES,
|
|
"max-gcse-passes",
|
|
"The maximum number of passes to make when doing GCSE",
|
|
1)
|
|
|
|
/* This parameter limits the number of insns in a loop that will be unrolled,
|
|
and by how much the loop is unrolled.
|
|
|
|
This limit should be at most half of the peeling limits: loop unroller
|
|
decides to not unroll loops that iterate fewer than 2*number of allowed
|
|
unrollings and thus we would have loops that are neither peeled or unrooled
|
|
otherwise. */
|
|
DEFPARAM(PARAM_MAX_UNROLLED_INSNS,
|
|
"max-unrolled-insns",
|
|
"The maximum number of instructions to consider to unroll in a loop",
|
|
200)
|
|
/* This parameter limits how many times the loop is unrolled depending
|
|
on number of insns really executed in each iteration. */
|
|
DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS,
|
|
"max-average-unrolled-insns",
|
|
"The maximum number of instructions to consider to unroll in a loop on average",
|
|
80)
|
|
/* The maximum number of unrollings of a single loop. */
|
|
DEFPARAM(PARAM_MAX_UNROLL_TIMES,
|
|
"max-unroll-times",
|
|
"The maximum number of unrollings of a single loop",
|
|
8)
|
|
/* The maximum number of insns of a peeled loop. */
|
|
DEFPARAM(PARAM_MAX_PEELED_INSNS,
|
|
"max-peeled-insns",
|
|
"The maximum number of insns of a peeled loop",
|
|
400)
|
|
/* The maximum number of peelings of a single loop. */
|
|
DEFPARAM(PARAM_MAX_PEEL_TIMES,
|
|
"max-peel-times",
|
|
"The maximum number of peelings of a single loop",
|
|
16)
|
|
/* The maximum number of insns of a peeled loop. */
|
|
DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
|
|
"max-completely-peeled-insns",
|
|
"The maximum number of insns of a completely peeled loop",
|
|
400)
|
|
/* The maximum number of peelings of a single loop that is peeled completely. */
|
|
DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
|
|
"max-completely-peel-times",
|
|
"The maximum number of peelings of a single loop that is peeled completely",
|
|
16)
|
|
/* The maximum number of insns of a peeled loop that rolls only once. */
|
|
DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS,
|
|
"max-once-peeled-insns",
|
|
"The maximum number of insns of a peeled loop that rolls only once",
|
|
400)
|
|
|
|
/* The maximum number of insns of an unswitched loop. */
|
|
DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
|
|
"max-unswitch-insns",
|
|
"The maximum number of insns of an unswitched loop",
|
|
50)
|
|
/* The maximum level of recursion in unswitch_single_loop. */
|
|
DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL,
|
|
"max-unswitch-level",
|
|
"The maximum number of unswitchings in a single loop",
|
|
3)
|
|
|
|
DEFPARAM(HOT_BB_COUNT_FRACTION,
|
|
"hot-bb-count-fraction",
|
|
"Select fraction of the maximal count of repetitions of basic block in \
|
|
program given basic block needs to have to be considered hot",
|
|
10000)
|
|
DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
|
|
"hot-bb-frequency-fraction",
|
|
"Select fraction of the maximal frequency of executions of basic \
|
|
block in function given basic block needs to have to be considered hot",
|
|
1000)
|
|
DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
|
|
"tracer-dynamic-coverage-feedback",
|
|
"The percentage of function, weighted by execution frequency, that \
|
|
must be covered by trace formation. Used when profile feedback is available",
|
|
95)
|
|
DEFPARAM(TRACER_DYNAMIC_COVERAGE,
|
|
"tracer-dynamic-coverage",
|
|
"The percentage of function, weighted by execution frequency, that \
|
|
must be covered by trace formation. Used when profile feedback is not available",
|
|
75)
|
|
DEFPARAM(TRACER_MAX_CODE_GROWTH,
|
|
"tracer-max-code-growth",
|
|
"Maximal code growth caused by tail duplication (in percent)",
|
|
100)
|
|
DEFPARAM(TRACER_MIN_BRANCH_RATIO,
|
|
"tracer-min-branch-ratio",
|
|
"Stop reverse growth if the reverse probability of best edge is less \
|
|
than this threshold (in percent)",
|
|
10)
|
|
DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK,
|
|
"tracer-min-branch-probability-feedback",
|
|
"Stop forward growth if the probability of best edge is less than \
|
|
this threshold (in percent). Used when profile feedback is available",
|
|
80)
|
|
DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY,
|
|
"tracer-min-branch-probability",
|
|
"Stop forward growth if the probability of best edge is less than \
|
|
this threshold (in percent). Used when profile feedback is not available",
|
|
50)
|
|
|
|
/* The maximum number of incoming edges to consider for crossjumping. */
|
|
DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES,
|
|
"max-crossjump-edges",
|
|
"The maximum number of incoming edges to consider for crossjumping",
|
|
100)
|
|
|
|
/* The maximum length of path considered in cse. */
|
|
DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
|
|
"max-cse-path-length",
|
|
"The maximum length of path considered in cse",
|
|
10)
|
|
|
|
DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
|
|
"max-cselib-memory-locations",
|
|
"The maximum memory locations recorded by cselib",
|
|
500)
|
|
|
|
#ifdef ENABLE_GC_ALWAYS_COLLECT
|
|
# define GGC_MIN_EXPAND_DEFAULT 0
|
|
# define GGC_MIN_HEAPSIZE_DEFAULT 0
|
|
#else
|
|
# define GGC_MIN_EXPAND_DEFAULT 30
|
|
# define GGC_MIN_HEAPSIZE_DEFAULT 4096
|
|
#endif
|
|
|
|
DEFPARAM(GGC_MIN_EXPAND,
|
|
"ggc-min-expand",
|
|
"Minimum heap expansion to trigger garbage collection, as \
|
|
a percentage of the total size of the heap",
|
|
GGC_MIN_EXPAND_DEFAULT)
|
|
|
|
DEFPARAM(GGC_MIN_HEAPSIZE,
|
|
"ggc-min-heapsize",
|
|
"Minimum heap size before we start collecting garbage, in kilobytes",
|
|
GGC_MIN_HEAPSIZE_DEFAULT)
|
|
|
|
#undef GGC_MIN_EXPAND_DEFAULT
|
|
#undef GGC_MIN_HEAPSIZE_DEFAULT
|
|
|
|
DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS,
|
|
"max-reload-search-insns",
|
|
"The maximum number of instructions to search backward when looking for equivalent reload",
|
|
100)
|
|
|
|
/*
|
|
Local variables:
|
|
mode:c
|
|
End: */
|