/* 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 300. | |

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", | |

300) | |

/* 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 300. */ | |

DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, | |

"max-inline-insns-auto", | |

"The maximum number of instructions when automatically inlining", | |

300) | |

/* The repeated inlining limit. After this number of instructions | |

(in the internal gcc representation, not real machine instructions) | |

got inlined by repeated inlining, gcc starts to decrease the maximum | |

number of inlinable instructions in the tree inliner. | |

This is done by a linear function, see "max-inline-slope" parameter. | |

It is necessary in order to limit the compile-time resources, that | |

could otherwise become very high. | |

It is recommended to set this value to twice the value of the single | |

function limit (set by the "max-inline-insns-single" parameter) or | |

higher. The default value is 600. | |

Higher values mean that more inlining is done, resulting in | |

better performance of the code, at the expense of higher | |

compile-time resource (time, memory) requirements and larger | |

binaries. */ | |

DEFPARAM (PARAM_MAX_INLINE_INSNS, | |

"max-inline-insns", | |

"The maximum number of instructions by repeated inlining before gcc starts to throttle inlining", | |

600) | |

/* After the repeated inline limit has been exceeded (see | |

"max-inline-insns" parameter), a linear function is used to | |

decrease the size of single functions eligible for inlining. | |

The slope of this linear function is given the negative | |

reciprocal value (-1/x) of this parameter. | |

The default value is 32. | |

This linear function is used until it falls below a minimum | |

value specified by the "min-inline-insns" parameter. */ | |

DEFPARAM (PARAM_MAX_INLINE_SLOPE, | |

"max-inline-slope", | |

"The slope of the linear function throttling inlining after the recursive inlining limit has been reached is given by the negative reciprocal value of this parameter", | |

32) | |

/* When gcc has inlined so many instructions (by repeated | |

inlining) that the throttling limits the inlining very much, | |

inlining for very small functions is still desirable to | |

achieve good runtime performance. The size of single functions | |

(measured in gcc instructions) which will still be eligible for | |

inlining then is given by this parameter. It defaults to 130. | |

Only much later (after exceeding 128 times the recursive limit) | |

inlining is cut down completely. */ | |

DEFPARAM (PARAM_MIN_INLINE_INSNS, | |

"min-inline-insns", | |

"The number of instructions in a single functions still eligible to inlining after a lot recursive inlining", | |

130) | |

/* 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) | |

/* 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. */ | |

DEFPARAM(PARAM_MAX_UNROLLED_INSNS, | |

"max-unrolled-insns", | |

"The maximum number of instructions to consider to unroll in a loop", | |

100) | |

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 percents)", | |

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 percents)", | |

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 percents). Used when profile feedback is available", | |

30) | |

DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, | |

"tracer-min-branch-probability", | |

"Stop forward growth if the probability of best edge is less than \ | |

this threshold (in percents). 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) | |

#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 | |

/* | |

Local variables: | |

mode:c | |

End: */ |