X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fparams.def;h=5642be4ad7baed379b449623a2dbee284534a7e0;hb=7d22b398620fcbf8df083b5283aac02a6f9f370b;hp=749414f6e9c5dd1d07be1146040c6472435ac715;hpb=9159979b4644af28303f47166397aa5d3802b115;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/params.def b/gcc/params.def index 749414f6e9c..5642be4ad7b 100644 --- a/gcc/params.def +++ b/gcc/params.def @@ -1,23 +1,23 @@ /* params.def - Run-time parameters. - Copyright (C) 2001 Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. Written by Mark Mitchell . -This file is part of GNU CC. +This file is part of GCC. -GNU CC 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 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. -GNU CC 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. +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 GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. +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. */ @@ -31,18 +31,49 @@ Boston, MA 02111-1307, USA. - A help string explaining how the parameter is used. - - A default value for the parameter. */ + - A default value for the parameter. -/* The maximum number of instructions accepted for inlining a - function. Increasing values mean more agressive inlining. - This affects currently only functions explicitly marked as - inline (or methods defined within the class definition for C++). - The default value of 10000 is arbitrary but high to match the - previously unlimited gcc capabilities. */ -DEFPARAM (PARAM_MAX_INLINE_INSNS, - "max-inline-insns", - "The maximum number of instructions in a function that is eligible for inlining", - 10000) + 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", + 120) + +/* 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 @@ -66,12 +97,178 @@ DEFPARAM(PARAM_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. */ +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", + 120) +/* 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", + 120) +/* 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", + 200) + +/* 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: