Mercurial > hg > CbC > CbC_gcc
annotate gcc/params.def @ 108:7ad14f446135
add CbC-example/rectypeTest/
| author | Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Thu, 14 Jun 2012 20:30:24 +0900 |
| parents | f6334be47118 |
| children | 04ced10e8804 |
| rev | line source |
|---|---|
| 0 | 1 /* params.def - Run-time parameters. |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3 2011 |
| 0 | 4 Free Software Foundation, Inc. |
| 5 Written by Mark Mitchell <mark@codesourcery.com>. | |
| 6 | |
| 7 This file is part of GCC. | |
| 8 | |
| 9 GCC is free software; you can redistribute it and/or modify it under | |
| 10 the terms of the GNU General Public License as published by the Free | |
| 11 Software Foundation; either version 3, or (at your option) any later | |
| 12 version. | |
| 13 | |
| 14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 15 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
| 20 along with GCC; see the file COPYING3. If not see | |
| 21 <http://www.gnu.org/licenses/>. */ | |
| 22 | |
| 23 /* This file contains definitions for language-independent | |
| 24 parameters. The DEFPARAM macro takes 6 arguments: | |
| 25 | |
| 26 - The enumeral corresponding to this parameter. | |
| 27 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
28 - The name that can be used to set this parameter using the |
| 0 | 29 command-line option `--param <name>=<value>'. |
| 30 | |
| 31 - A help string explaining how the parameter is used. | |
| 32 | |
| 33 - A default value for the parameter. | |
| 34 | |
| 35 - The minimum acceptable value for the parameter. | |
| 36 | |
| 37 - The maximum acceptable value for the parameter (if greater than | |
| 38 the minimum). | |
| 39 | |
| 40 Be sure to add an entry to invoke.texi summarizing the parameter. */ | |
| 41 | |
| 42 /* The threshold ratio between current and hottest structure counts. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
43 We say that if the ratio of the current structure count, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
44 calculated by profiling, to the hottest structure count |
| 0 | 45 in the program is less than this parameter, then structure |
| 46 reorganization is not applied. The default is 10%. */ | |
| 47 DEFPARAM (PARAM_STRUCT_REORG_COLD_STRUCT_RATIO, | |
| 48 "struct-reorg-cold-struct-ratio", | |
| 49 "The threshold ratio between current and hottest structure counts", | |
| 50 10, 0, 100) | |
| 51 | |
| 52 /* When branch is predicted to be taken with probability lower than this | |
| 53 threshold (in percent), then it is considered well predictable. */ | |
| 54 DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME, | |
| 55 "predictable-branch-outcome", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
56 "Maximal estimated outcome of branch considered predictable", |
| 0 | 57 2, 0, 50) |
| 58 | |
| 59 /* The single function inlining limit. This is the maximum size | |
| 60 of a function counted in internal gcc instructions (not in | |
| 61 real machine instructions) that is eligible for inlining | |
| 62 by the tree inliner. | |
| 63 The default value is 450. | |
| 64 Only functions marked inline (or methods defined in the class | |
| 65 definition for C++) are affected by this. | |
| 66 There are more restrictions to inlining: If inlined functions | |
| 67 call other functions, the already inlined instructions are | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
68 counted and once the recursive inline limit (see |
| 0 | 69 "max-inline-insns" parameter) is exceeded, the acceptable size |
| 70 gets decreased. */ | |
| 71 DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE, | |
| 72 "max-inline-insns-single", | |
| 73 "The maximum number of instructions in a single function eligible for inlining", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
74 400, 0, 0) |
| 0 | 75 |
| 76 /* The single function inlining limit for functions that are | |
| 77 inlined by virtue of -finline-functions (-O3). | |
| 78 This limit should be chosen to be below or equal to the limit | |
| 79 that is applied to functions marked inlined (or defined in the | |
| 80 class declaration in C++) given by the "max-inline-insns-single" | |
| 81 parameter. | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
82 The default value is 40. */ |
| 0 | 83 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, |
| 84 "max-inline-insns-auto", | |
| 85 "The maximum number of instructions when automatically inlining", | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
86 40, 0, 0) |
| 0 | 87 |
| 88 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, | |
| 89 "max-inline-insns-recursive", | |
| 90 "The maximum number of instructions inline function can grow to via recursive inlining", | |
| 91 450, 0, 0) | |
| 92 | |
| 93 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO, | |
| 94 "max-inline-insns-recursive-auto", | |
| 95 "The maximum number of instructions non-inline function can grow to via recursive inlining", | |
| 96 450, 0, 0) | |
| 97 | |
| 98 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH, | |
| 99 "max-inline-recursive-depth", | |
| 100 "The maximum depth of recursive inlining for inline functions", | |
| 101 8, 0, 0) | |
| 102 | |
| 103 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO, | |
| 104 "max-inline-recursive-depth-auto", | |
| 105 "The maximum depth of recursive inlining for non-inline functions", | |
| 106 8, 0, 0) | |
| 107 | |
| 108 DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY, | |
| 109 "min-inline-recursive-probability", | |
| 110 "Inline recursively only when the probability of call being executed exceeds the parameter", | |
| 111 10, 0, 0) | |
| 112 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
113 /* Limit of iterations of early inliner. This basically bounds number of |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
114 nested indirect calls early inliner can resolve. Deeper chains are still |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
115 handled by late inlining. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
116 DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
117 "max-early-inliner-iterations", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
118 "The maximum number of nested indirect inlining performed by early inliner", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
119 10, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
120 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
121 /* Limit on probability of entry BB. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
122 DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
123 "comdat-sharing-probability", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
124 "Probability that COMDAT function will be shared with different compilatoin unit", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
125 20, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
126 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
127 /* Limit on probability of entry BB. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
128 DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
129 "partial-inlining-entry-probability", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
130 "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
131 70, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
132 |
| 0 | 133 /* Limit the number of expansions created by the variable expansion |
| 134 optimization to avoid register pressure. */ | |
| 135 DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS, | |
| 136 "max-variable-expansions-in-unroller", | |
| 137 "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling", | |
| 138 1, 0, 0) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
139 |
| 0 | 140 /* Limit loop autovectorization to loops with large enough iteration count. */ |
| 141 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, | |
| 142 "min-vect-loop-bound", | |
| 143 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization", | |
| 144 1, 1, 0) | |
| 145 | |
| 146 /* The maximum number of instructions to consider when looking for an | |
| 147 instruction to fill a delay slot. If more than this arbitrary | |
| 148 number of instructions is searched, the time savings from filling | |
| 149 the delay slot will be minimal so stop searching. Increasing | |
| 150 values mean more aggressive optimization, making the compile time | |
| 151 increase with probably small improvement in executable run time. */ | |
| 152 DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH, | |
| 153 "max-delay-slot-insn-search", | |
| 154 "The maximum number of instructions to consider to fill a delay slot", | |
| 155 100, 0, 0) | |
| 156 | |
| 157 /* When trying to fill delay slots, the maximum number of instructions | |
| 158 to consider when searching for a block with valid live register | |
| 159 information. Increasing this arbitrarily chosen value means more | |
| 160 aggressive optimization, increasing the compile time. This | |
| 161 parameter should be removed when the delay slot code is rewritten | |
| 162 to maintain the control-flow graph. */ | |
| 163 DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH, | |
| 164 "max-delay-slot-live-search", | |
| 165 "The maximum number of instructions to consider to find accurate live register information", | |
| 166 333, 0, 0) | |
| 167 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
168 /* This parameter limits the number of branch elements that the |
| 0 | 169 scheduler will track anti-dependencies through without resetting |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
170 the tracking mechanism. Large functions with few calls or barriers |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
171 can generate lists containing many 1000's of dependencies. Generally |
| 0 | 172 the compiler either uses all available memory, or runs for far too long. */ |
| 173 DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH, | |
| 174 "max-pending-list-length", | |
| 175 "The maximum length of scheduling's pending operations list", | |
| 176 32, 0, 0) | |
| 177 | |
| 178 DEFPARAM(PARAM_LARGE_FUNCTION_INSNS, | |
| 179 "large-function-insns", | |
| 180 "The size of function body to be considered large", | |
| 181 2700, 0, 0) | |
| 182 DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH, | |
| 183 "large-function-growth", | |
| 184 "Maximal growth due to inlining of large function (in percent)", | |
| 185 100, 0, 0) | |
| 186 DEFPARAM(PARAM_LARGE_UNIT_INSNS, | |
| 187 "large-unit-insns", | |
| 188 "The size of translation unit to be considered large", | |
| 189 10000, 0, 0) | |
| 190 DEFPARAM(PARAM_INLINE_UNIT_GROWTH, | |
| 191 "inline-unit-growth", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
192 "How much can given compilation unit grow because of the inlining (in percent)", |
| 0 | 193 30, 0, 0) |
| 194 DEFPARAM(PARAM_IPCP_UNIT_GROWTH, | |
| 195 "ipcp-unit-growth", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
196 "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)", |
| 0 | 197 10, 0, 0) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
198 DEFPARAM(PARAM_EARLY_INLINING_INSNS, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
199 "early-inlining-insns", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
200 "Maximal estimated growth of function body caused by early inlining of single call", |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
201 10, 0, 0) |
| 0 | 202 DEFPARAM(PARAM_LARGE_STACK_FRAME, |
| 203 "large-stack-frame", | |
| 204 "The size of stack frame to be considered large", | |
| 205 256, 0, 0) | |
| 206 DEFPARAM(PARAM_STACK_FRAME_GROWTH, | |
| 207 "large-stack-frame-growth", | |
| 208 "Maximal stack frame growth due to inlining (in percent)", | |
| 209 1000, 0, 0) | |
| 210 | |
| 211 /* The GCSE optimization will be disabled if it would require | |
| 212 significantly more memory than this value. */ | |
| 213 DEFPARAM(PARAM_MAX_GCSE_MEMORY, | |
| 214 "max-gcse-memory", | |
| 215 "The maximum amount of memory to be allocated by GCSE", | |
| 216 50 * 1024 * 1024, 0, 0) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
217 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
218 /* The GCSE optimization of an expression will avoided if the ratio of |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
219 insertions to deletions is greater than this value. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
220 DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
221 "max-gcse-insertion-ratio", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
222 "The maximum ratio of insertions to deletions of expressions in GCSE", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
223 20, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
224 |
| 0 | 225 /* This is the threshold ratio when to perform partial redundancy |
| 226 elimination after reload. We perform partial redundancy elimination | |
| 227 when the following holds: | |
| 228 (Redundant load execution count) | |
| 229 ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION | |
| 230 (Added loads execution count) */ | |
| 231 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION, | |
| 232 "gcse-after-reload-partial-fraction", | |
| 233 "The threshold ratio for performing partial redundancy elimination after reload", | |
| 234 3, 0, 0) | |
| 235 /* This is the threshold ratio of the critical edges execution count compared to | |
| 236 the redundant loads execution count that permits performing the load | |
| 237 redundancy elimination in gcse after reload. */ | |
| 238 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION, | |
| 239 "gcse-after-reload-critical-fraction", | |
| 240 "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload", | |
| 241 10, 0, 0) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
242 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
243 /* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
244 to calculate maximum distance for which an expression is allowed to move |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
245 from its rtx_cost. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
246 DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
247 "gcse-cost-distance-ratio", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
248 "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
249 10, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
250 /* GCSE won't restrict distance for which an expression with rtx_cost greater |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
251 than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
252 DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
253 "gcse-unrestricted-cost", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
254 "Cost at which GCSE optimizations will not constraint the distance an expression can travel", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
255 3, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
256 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
257 /* How deep from a given basic block the dominator tree should be searched |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
258 for expressions to hoist to the block. The value of 0 will avoid limiting |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
259 the search. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
260 DEFPARAM(PARAM_MAX_HOIST_DEPTH, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
261 "max-hoist-depth", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
262 "Maximum depth of search in the dominator tree for expressions to hoist", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
263 30, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
264 |
| 0 | 265 /* This parameter limits the number of insns in a loop that will be unrolled, |
| 266 and by how much the loop is unrolled. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
267 |
| 0 | 268 This limit should be at most half of the peeling limits: loop unroller |
| 269 decides to not unroll loops that iterate fewer than 2*number of allowed | |
| 270 unrollings and thus we would have loops that are neither peeled or unrolled | |
| 271 otherwise. */ | |
| 272 DEFPARAM(PARAM_MAX_UNROLLED_INSNS, | |
| 273 "max-unrolled-insns", | |
| 274 "The maximum number of instructions to consider to unroll in a loop", | |
| 275 200, 0, 0) | |
| 276 /* This parameter limits how many times the loop is unrolled depending | |
| 277 on number of insns really executed in each iteration. */ | |
| 278 DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS, | |
| 279 "max-average-unrolled-insns", | |
| 280 "The maximum number of instructions to consider to unroll in a loop on average", | |
| 281 80, 0, 0) | |
| 282 /* The maximum number of unrollings of a single loop. */ | |
| 283 DEFPARAM(PARAM_MAX_UNROLL_TIMES, | |
| 284 "max-unroll-times", | |
| 285 "The maximum number of unrollings of a single loop", | |
| 286 8, 0, 0) | |
| 287 /* The maximum number of insns of a peeled loop. */ | |
| 288 DEFPARAM(PARAM_MAX_PEELED_INSNS, | |
| 289 "max-peeled-insns", | |
| 290 "The maximum number of insns of a peeled loop", | |
| 291 400, 0, 0) | |
| 292 /* The maximum number of peelings of a single loop. */ | |
| 293 DEFPARAM(PARAM_MAX_PEEL_TIMES, | |
| 294 "max-peel-times", | |
| 295 "The maximum number of peelings of a single loop", | |
| 296 16, 0, 0) | |
| 297 /* The maximum number of insns of a peeled loop. */ | |
| 298 DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS, | |
| 299 "max-completely-peeled-insns", | |
| 300 "The maximum number of insns of a completely peeled loop", | |
| 301 400, 0, 0) | |
| 302 /* The maximum number of peelings of a single loop that is peeled completely. */ | |
| 303 DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES, | |
| 304 "max-completely-peel-times", | |
| 305 "The maximum number of peelings of a single loop that is peeled completely", | |
| 306 16, 0, 0) | |
| 307 /* The maximum number of insns of a peeled loop that rolls only once. */ | |
| 308 DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS, | |
| 309 "max-once-peeled-insns", | |
| 310 "The maximum number of insns of a peeled loop that rolls only once", | |
| 311 400, 0, 0) | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
312 /* The maximum depth of a loop nest we completely peel. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
313 DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
314 "max-completely-peel-loop-nest-depth", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
315 "The maximum depth of a loop nest we completely peel", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
316 8, 0, 0) |
| 0 | 317 |
| 318 /* The maximum number of insns of an unswitched loop. */ | |
| 319 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS, | |
| 320 "max-unswitch-insns", | |
| 321 "The maximum number of insns of an unswitched loop", | |
| 322 50, 0, 0) | |
| 323 /* The maximum level of recursion in unswitch_single_loop. */ | |
| 324 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, | |
| 325 "max-unswitch-level", | |
| 326 "The maximum number of unswitchings in a single loop", | |
| 327 3, 0, 0) | |
| 328 | |
| 329 /* The maximum number of iterations of a loop the brute force algorithm | |
| 330 for analysis of # of iterations of the loop tries to evaluate. */ | |
| 331 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, | |
| 332 "max-iterations-to-track", | |
| 333 "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates", | |
| 334 1000, 0, 0) | |
| 335 /* A cutoff to avoid costly computations of the number of iterations in | |
| 336 the doloop transformation. */ | |
| 337 DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST, | |
| 338 "max-iterations-computation-cost", | |
| 339 "Bound on the cost of an expression to compute the number of iterations", | |
| 340 10, 0, 0) | |
| 341 | |
| 342 /* This parameter is used to tune SMS MAX II calculations. */ | |
| 343 DEFPARAM(PARAM_SMS_MAX_II_FACTOR, | |
| 344 "sms-max-ii-factor", | |
| 345 "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop", | |
| 346 100, 0, 0) | |
| 347 DEFPARAM(PARAM_SMS_DFA_HISTORY, | |
| 348 "sms-dfa-history", | |
| 349 "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA", | |
| 350 0, 0, 0) | |
| 351 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, | |
| 352 "sms-loop-average-count-threshold", | |
| 353 "A threshold on the average loop count considered by the swing modulo scheduler", | |
| 354 0, 0, 0) | |
| 355 | |
| 356 DEFPARAM(HOT_BB_COUNT_FRACTION, | |
| 357 "hot-bb-count-fraction", | |
| 358 "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot", | |
| 359 10000, 0, 0) | |
| 360 DEFPARAM(HOT_BB_FREQUENCY_FRACTION, | |
| 361 "hot-bb-frequency-fraction", | |
| 362 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot", | |
| 363 1000, 0, 0) | |
| 364 | |
| 365 DEFPARAM (PARAM_ALIGN_THRESHOLD, | |
| 366 "align-threshold", | |
| 367 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment", | |
| 368 100, 0, 0) | |
| 369 | |
| 370 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, | |
| 371 "align-loop-iterations", | |
| 372 "Loops iterating at least selected number of iterations will get loop alignement.", | |
| 373 4, 0, 0) | |
| 374 | |
| 375 /* For guessed profiles, the loops having unknown number of iterations | |
| 376 are predicted to iterate relatively few (10) times at average. | |
| 377 For functions containing one loop with large known number of iterations | |
| 378 and other loops having unbounded loops we would end up predicting all | |
| 379 the other loops cold that is not usually the case. So we need to artificially | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
380 flatten the profile. |
| 0 | 381 |
| 382 We need to cut the maximal predicted iterations to large enough iterations | |
| 383 so the loop appears important, but safely within HOT_BB_COUNT_FRACTION | |
| 384 range. */ | |
| 385 | |
| 386 DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS, | |
| 387 "max-predicted-iterations", | |
| 388 "The maximum number of loop iterations we predict statically", | |
| 389 100, 0, 0) | |
| 390 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, | |
| 391 "tracer-dynamic-coverage-feedback", | |
| 392 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available", | |
| 393 95, 0, 100) | |
| 394 DEFPARAM(TRACER_DYNAMIC_COVERAGE, | |
| 395 "tracer-dynamic-coverage", | |
| 396 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available", | |
| 397 75, 0, 100) | |
| 398 DEFPARAM(TRACER_MAX_CODE_GROWTH, | |
| 399 "tracer-max-code-growth", | |
| 400 "Maximal code growth caused by tail duplication (in percent)", | |
| 401 100, 0, 0) | |
| 402 DEFPARAM(TRACER_MIN_BRANCH_RATIO, | |
| 403 "tracer-min-branch-ratio", | |
| 404 "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)", | |
| 405 10, 0, 100) | |
| 406 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK, | |
| 407 "tracer-min-branch-probability-feedback", | |
| 408 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available", | |
| 409 80, 0, 100) | |
| 410 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, | |
| 411 "tracer-min-branch-probability", | |
| 412 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available", | |
| 413 50, 0, 100) | |
| 414 | |
| 415 /* The maximum number of incoming edges to consider for crossjumping. */ | |
| 416 DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES, | |
| 417 "max-crossjump-edges", | |
| 418 "The maximum number of incoming edges to consider for crossjumping", | |
| 419 100, 0, 0) | |
| 420 | |
| 421 /* The minimum number of matching instructions to consider for crossjumping. */ | |
| 422 DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS, | |
| 423 "min-crossjump-insns", | |
| 424 "The minimum number of matching instructions to consider for crossjumping", | |
| 425 5, 0, 0) | |
| 426 | |
| 427 /* The maximum number expansion factor when copying basic blocks. */ | |
| 428 DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS, | |
| 429 "max-grow-copy-bb-insns", | |
| 430 "The maximum expansion factor when copying basic blocks", | |
| 431 8, 0, 0) | |
| 432 | |
| 433 /* The maximum number of insns to duplicate when unfactoring computed gotos. */ | |
| 434 DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS, | |
| 435 "max-goto-duplication-insns", | |
| 436 "The maximum number of insns to duplicate when unfactoring computed gotos", | |
| 437 8, 0, 0) | |
| 438 | |
| 439 /* The maximum length of path considered in cse. */ | |
| 440 DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH, | |
| 441 "max-cse-path-length", | |
| 442 "The maximum length of path considered in cse", | |
| 443 10, 0, 0) | |
| 444 DEFPARAM(PARAM_MAX_CSE_INSNS, | |
| 445 "max-cse-insns", | |
| 446 "The maximum instructions CSE process before flushing", | |
| 447 1000, 0, 0) | |
| 448 | |
| 449 /* The cost of expression in loop invariant motion that is considered | |
| 450 expensive. */ | |
| 451 DEFPARAM(PARAM_LIM_EXPENSIVE, | |
| 452 "lim-expensive", | |
| 453 "The minimum cost of an expensive expression in the loop invariant motion", | |
| 454 20, 0, 0) | |
| 455 | |
| 456 /* Bound on number of candidates for induction variables below that | |
| 457 all candidates are considered for each use in induction variable | |
| 458 optimizations. */ | |
| 459 | |
| 460 DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, | |
| 461 "iv-consider-all-candidates-bound", | |
| 462 "Bound on number of candidates below that all candidates are considered in iv optimizations", | |
| 463 30, 0, 0) | |
| 464 | |
| 465 /* The induction variable optimizations give up on loops that contain more | |
| 466 induction variable uses. */ | |
| 467 | |
| 468 DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES, | |
| 469 "iv-max-considered-uses", | |
| 470 "Bound on number of iv uses in loop optimized in iv optimizations", | |
| 471 250, 0, 0) | |
| 472 | |
| 473 /* If there are at most this number of ivs in the set, try removing unnecessary | |
| 474 ivs from the set always. */ | |
| 475 | |
| 476 DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, | |
| 477 "iv-always-prune-cand-set-bound", | |
| 478 "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization", | |
| 479 10, 0, 0) | |
| 480 | |
| 481 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, | |
| 482 "scev-max-expr-size", | |
| 483 "Bound on size of expressions used in the scalar evolutions analyzer", | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
484 100, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
485 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
486 DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
487 "scev-max-expr-complexity", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
488 "Bound on the complexity of the expressions in the scalar evolutions analyzer", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
489 10, 0, 0) |
| 0 | 490 |
| 491 DEFPARAM(PARAM_OMEGA_MAX_VARS, | |
| 492 "omega-max-vars", | |
| 493 "Bound on the number of variables in Omega constraint systems", | |
| 494 128, 0, 0) | |
| 495 | |
| 496 DEFPARAM(PARAM_OMEGA_MAX_GEQS, | |
| 497 "omega-max-geqs", | |
| 498 "Bound on the number of inequalities in Omega constraint systems", | |
| 499 256, 0, 0) | |
| 500 | |
| 501 DEFPARAM(PARAM_OMEGA_MAX_EQS, | |
| 502 "omega-max-eqs", | |
| 503 "Bound on the number of equalities in Omega constraint systems", | |
| 504 128, 0, 0) | |
| 505 | |
| 506 DEFPARAM(PARAM_OMEGA_MAX_WILD_CARDS, | |
| 507 "omega-max-wild-cards", | |
| 508 "Bound on the number of wild cards in Omega constraint systems", | |
| 509 18, 0, 0) | |
| 510 | |
| 511 DEFPARAM(PARAM_OMEGA_HASH_TABLE_SIZE, | |
| 512 "omega-hash-table-size", | |
| 513 "Bound on the size of the hash table in Omega constraint systems", | |
| 514 550, 0, 0) | |
| 515 | |
| 516 DEFPARAM(PARAM_OMEGA_MAX_KEYS, | |
| 517 "omega-max-keys", | |
| 518 "Bound on the number of keys in Omega constraint systems", | |
| 519 500, 0, 0) | |
| 520 | |
| 521 DEFPARAM(PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS, | |
| 522 "omega-eliminate-redundant-constraints", | |
| 523 "When set to 1, use expensive methods to eliminate all redundant constraints", | |
| 524 0, 0, 1) | |
| 525 | |
| 526 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS, | |
| 527 "vect-max-version-for-alignment-checks", | |
| 528 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check", | |
| 529 6, 0, 0) | |
| 530 | |
| 531 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, | |
| 532 "vect-max-version-for-alias-checks", | |
| 533 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check", | |
| 534 10, 0, 0) | |
| 535 | |
| 536 DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS, | |
| 537 "max-cselib-memory-locations", | |
| 538 "The maximum memory locations recorded by cselib", | |
| 539 500, 0, 0) | |
| 540 | |
| 541 #ifdef ENABLE_GC_ALWAYS_COLLECT | |
| 542 # define GGC_MIN_EXPAND_DEFAULT 0 | |
| 543 # define GGC_MIN_HEAPSIZE_DEFAULT 0 | |
| 544 #else | |
| 545 # define GGC_MIN_EXPAND_DEFAULT 30 | |
| 546 # define GGC_MIN_HEAPSIZE_DEFAULT 4096 | |
| 547 #endif | |
| 548 | |
| 549 DEFPARAM(GGC_MIN_EXPAND, | |
| 550 "ggc-min-expand", | |
| 551 "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap", | |
| 552 GGC_MIN_EXPAND_DEFAULT, 0, 0) | |
| 553 | |
| 554 DEFPARAM(GGC_MIN_HEAPSIZE, | |
| 555 "ggc-min-heapsize", | |
| 556 "Minimum heap size before we start collecting garbage, in kilobytes", | |
| 557 GGC_MIN_HEAPSIZE_DEFAULT, 0, 0) | |
| 558 | |
| 559 #undef GGC_MIN_EXPAND_DEFAULT | |
| 560 #undef GGC_MIN_HEAPSIZE_DEFAULT | |
| 561 | |
| 562 DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS, | |
| 563 "max-reload-search-insns", | |
| 564 "The maximum number of instructions to search backward when looking for equivalent reload", | |
| 565 100, 0, 0) | |
| 566 | |
| 567 DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS, | |
| 568 "max-sched-region-blocks", | |
| 569 "The maximum number of blocks in a region to be considered for interblock scheduling", | |
| 570 10, 0, 0) | |
| 571 | |
| 572 DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS, | |
| 573 "max-sched-region-insns", | |
| 574 "The maximum number of insns in a region to be considered for interblock scheduling", | |
| 575 100, 0, 0) | |
| 576 | |
| 577 DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS, | |
| 578 "max-pipeline-region-blocks", | |
| 579 "The maximum number of blocks in a region to be considered for interblock scheduling", | |
| 580 15, 0, 0) | |
| 581 | |
| 582 DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS, | |
| 583 "max-pipeline-region-insns", | |
| 584 "The maximum number of insns in a region to be considered for interblock scheduling", | |
| 585 200, 0, 0) | |
| 586 | |
| 587 DEFPARAM(PARAM_MIN_SPEC_PROB, | |
| 588 "min-spec-prob", | |
| 589 "The minimum probability of reaching a source block for interblock speculative scheduling", | |
| 590 40, 0, 0) | |
| 591 | |
| 592 DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, | |
| 593 "max-sched-extend-regions-iters", | |
| 594 "The maximum number of iterations through CFG to extend regions", | |
| 595 0, 0, 0) | |
| 596 | |
| 597 DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY, | |
| 598 "max-sched-insn-conflict-delay", | |
| 599 "The maximum conflict delay for an insn to be considered for speculative motion", | |
| 600 3, 1, 10) | |
| 601 | |
| 602 DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF, | |
| 603 "sched-spec-prob-cutoff", | |
| 604 "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.", | |
| 605 40, 0, 100) | |
| 606 | |
| 607 DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD, | |
| 608 "selsched-max-lookahead", | |
| 609 "The maximum size of the lookahead window of selective scheduling", | |
| 610 50, 0, 0) | |
| 611 | |
| 612 DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES, | |
| 613 "selsched-max-sched-times", | |
| 614 "Maximum number of times that an insn could be scheduled", | |
| 615 2, 0, 0) | |
| 616 | |
| 617 DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME, | |
| 618 "selsched-insns-to-rename", | |
| 619 "Maximum number of instructions in the ready list that are considered eligible for renaming", | |
| 620 2, 0, 0) | |
| 621 | |
| 622 DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST, | |
| 623 "sched-mem-true-dep-cost", | |
| 624 "Minimal distance between possibly conflicting store and load", | |
| 625 1, 0, 0) | |
| 626 | |
| 627 DEFPARAM(PARAM_MAX_LAST_VALUE_RTL, | |
| 628 "max-last-value-rtl", | |
| 629 "The maximum number of RTL nodes that can be recorded as combiner's last value", | |
| 630 10000, 0, 0) | |
| 631 | |
| 632 /* INTEGER_CST nodes are shared for values [{-1,0} .. N) for | |
| 633 {signed,unsigned} integral types. This determines N. | |
| 634 Experimentation shows 256 to be a good value. */ | |
| 635 DEFPARAM (PARAM_INTEGER_SHARE_LIMIT, | |
| 636 "integer-share-limit", | |
| 637 "The upper bound for sharing integer constants", | |
| 638 256, 2, 2) | |
| 639 | |
| 640 /* Incremental SSA updates for virtual operands may be very slow if | |
| 641 there is a large number of mappings to process. In those cases, it | |
| 642 is faster to rewrite the virtual symbols from scratch as if they | |
| 643 had been recently introduced. This heuristic cannot be applied to | |
| 644 SSA mappings for real SSA names, only symbols kept in FUD chains. | |
| 645 | |
| 646 PARAM_MIN_VIRTUAL_MAPPINGS specifies the minimum number of virtual | |
| 647 mappings that should be registered to trigger the heuristic. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
648 |
| 0 | 649 PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO specifies the ratio between |
| 650 mappings and symbols. If the number of virtual mappings is | |
| 651 PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO bigger than the number of | |
| 652 virtual symbols to be updated, then the updater switches to a full | |
| 653 update for those symbols. */ | |
| 654 DEFPARAM (PARAM_MIN_VIRTUAL_MAPPINGS, | |
| 655 "min-virtual-mappings", | |
| 656 "Minimum number of virtual mappings to consider switching to full virtual renames", | |
| 657 100, 0, 0) | |
| 658 | |
| 659 DEFPARAM (PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO, | |
| 660 "virtual-mappings-ratio", | |
| 661 "Ratio between virtual mappings and virtual symbols to do full virtual renames", | |
| 662 3, 0, 0) | |
| 663 | |
| 664 DEFPARAM (PARAM_SSP_BUFFER_SIZE, | |
| 665 "ssp-buffer-size", | |
| 666 "The lower bound for a buffer to be considered for stack smashing protection", | |
| 667 8, 1, 0) | |
| 668 | |
| 669 /* When we thread through a block we have to make copies of the | |
| 670 statements within the block. Clearly for large blocks the code | |
| 671 duplication is bad. | |
| 672 | |
| 673 PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number | |
| 674 of statements and PHI nodes allowed in a block which is going to | |
| 675 be duplicated for thread jumping purposes. | |
| 676 | |
| 677 Some simple analysis showed that more than 99% of the jump | |
| 678 threading opportunities are for blocks with less than 15 | |
| 679 statements. So we can get the benefits of jump threading | |
| 680 without excessive code bloat for pathological cases with the | |
| 681 throttle set at 15 statements. */ | |
| 682 DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS, | |
| 683 "max-jump-thread-duplication-stmts", | |
| 684 "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps", | |
| 685 15, 0, 0) | |
| 686 | |
| 687 /* This is the maximum number of fields a variable may have before the pointer analysis machinery | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
688 will stop trying to treat it in a field-sensitive manner. |
| 0 | 689 There are programs out there with thousands of fields per structure, and handling them |
| 690 field-sensitively is not worth the cost. */ | |
| 691 DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE, | |
| 692 "max-fields-for-field-sensitive", | |
| 693 "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable", | |
| 694 0, 0, 0) | |
| 695 | |
| 696 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, | |
| 697 "max-sched-ready-insns", | |
| 698 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass", | |
| 699 100, 0, 0) | |
| 700 | |
| 701 /* Prefetching and cache-optimizations related parameters. Default values are | |
| 702 usually set by machine description. */ | |
| 703 | |
| 704 /* The number of insns executed before prefetch is completed. */ | |
| 705 | |
| 706 DEFPARAM (PARAM_PREFETCH_LATENCY, | |
| 707 "prefetch-latency", | |
| 708 "The number of insns executed before prefetch is completed", | |
| 709 200, 0, 0) | |
| 710 | |
| 711 /* The number of prefetches that can run at the same time. */ | |
| 712 | |
| 713 DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES, | |
| 714 "simultaneous-prefetches", | |
| 715 "The number of prefetches that can run at the same time", | |
| 716 3, 0, 0) | |
| 717 | |
| 718 /* The size of L1 cache in kB. */ | |
| 719 | |
| 720 DEFPARAM (PARAM_L1_CACHE_SIZE, | |
| 721 "l1-cache-size", | |
| 722 "The size of L1 cache", | |
| 723 64, 0, 0) | |
| 724 | |
| 725 /* The size of L1 cache line in bytes. */ | |
| 726 | |
| 727 DEFPARAM (PARAM_L1_CACHE_LINE_SIZE, | |
| 728 "l1-cache-line-size", | |
| 729 "The size of L1 cache line", | |
| 730 32, 0, 0) | |
| 731 | |
| 732 /* The size of L2 cache in kB. */ | |
| 733 | |
| 734 DEFPARAM (PARAM_L2_CACHE_SIZE, | |
| 735 "l2-cache-size", | |
| 736 "The size of L2 cache", | |
| 737 512, 0, 0) | |
| 738 | |
| 739 /* Whether we should use canonical types rather than deep "structural" | |
| 740 type checking. Setting this value to 1 (the default) improves | |
| 741 compilation performance in the C++ and Objective-C++ front end; | |
| 742 this value should only be set to zero to work around bugs in the | |
| 743 canonical type system by disabling it. */ | |
| 744 | |
| 745 DEFPARAM (PARAM_USE_CANONICAL_TYPES, | |
| 746 "use-canonical-types", | |
| 747 "Whether to use canonical types", | |
| 748 1, 0, 1) | |
| 749 | |
| 750 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, | |
| 751 "max-partial-antic-length", | |
| 752 "Maximum length of partial antic set when performing tree pre optimization", | |
| 753 100, 0, 0) | |
| 754 | |
| 755 /* The following is used as a stop-gap limit for cases where really huge | |
| 756 SCCs blow up memory and compile-time use too much. If we hit this limit, | |
| 757 SCCVN and such FRE and PRE will be not done at all for the current | |
| 758 function. */ | |
| 759 | |
| 760 DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE, | |
| 761 "sccvn-max-scc-size", | |
| 762 "Maximum size of a SCC before SCCVN stops processing a function", | |
| 763 10000, 10, 0) | |
| 764 | |
| 765 DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM, | |
| 766 "ira-max-loops-num", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
767 "Max loops number for regional RA", |
| 0 | 768 100, 0, 0) |
| 769 | |
| 770 DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE, | |
| 771 "ira-max-conflict-table-size", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
772 "Max size of conflict table in MB", |
| 0 | 773 1000, 0, 0) |
| 774 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
775 DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
776 "ira-loop-reserved-regs", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
777 "The number of registers in each class kept unused by loop invariant motion", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
778 2, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
779 |
| 0 | 780 /* Switch initialization conversion will refuse to create arrays that are |
| 781 bigger than this parameter times the number of switch branches. */ | |
| 782 | |
| 783 DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO, | |
| 784 "switch-conversion-max-branch-ratio", | |
| 785 "The maximum ratio between array size and switch branches for " | |
| 786 "a switch conversion to take place", | |
| 787 8, 1, 0) | |
| 788 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
789 /* Size of tiles when doing loop blocking. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
790 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
791 DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
792 "loop-block-tile-size", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
793 "size of tiles for loop blocking", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
794 51, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
795 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
796 /* Maximal number of parameters that we allow in a SCoP. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
797 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
798 DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
799 "graphite-max-nb-scop-params", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
800 "maximum number of parameters in a SCoP", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
801 10, 0, 0) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
802 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
803 /* Maximal number of basic blocks in the functions analyzed by Graphite. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
804 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
805 DEFPARAM (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
806 "graphite-max-bbs-per-function", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
807 "maximum number of basic blocks per function to be analyzed by Graphite", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
808 100, 0, 0) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
809 |
| 0 | 810 /* Avoid doing loop invariant motion on very large loops. */ |
| 811 | |
| 812 DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP, | |
| 813 "loop-invariant-max-bbs-in-loop", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
814 "Max basic blocks number in loop for loop invariant motion", |
| 0 | 815 10000, 0, 0) |
| 816 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
817 /* Avoid SLP vectorization of large basic blocks. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
818 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
819 "slp-max-insns-in-bb", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
820 "Maximum number of instructions in basic block to be considered for SLP vectorization", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
821 1000, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
822 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
823 DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
824 "min-insn-to-prefetch-ratio", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
825 "Min. ratio of insns to prefetches to enable prefetching for " |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
826 "a loop with an unknown trip count", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
827 10, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
828 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
829 DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
830 "prefetch-min-insn-to-mem-ratio", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
831 "Min. ratio of insns to mem ops to enable prefetching in a loop", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
832 3, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
833 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
834 /* Set maximum hash table size for var tracking. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
835 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
836 DEFPARAM (PARAM_MAX_VARTRACK_SIZE, |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
837 "max-vartrack-size", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
838 "Max. size of var tracking hash tables", |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
839 50000000, 0, 0) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
840 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
841 /* Set minimum insn uid for non-debug insns. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
842 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
843 DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
844 "min-nondebug-insn-uid", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
845 "The minimum UID to be used for a nondebug insn", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
846 0, 1, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
847 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
848 DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
849 "ipa-sra-ptr-growth-factor", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
850 "Maximum allowed growth of size of new parameters ipa-sra replaces " |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
851 "a pointer to an aggregate with", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
852 2, 0, 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
853 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
854 DEFPARAM (PARAM_DEVIRT_TYPE_LIST_SIZE, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
855 "devirt-type-list-size", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
856 "Maximum size of a type list associated with each parameter for " |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
857 "devirtualization", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
858 8, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
859 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
860 /* WHOPR partitioning configuration. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
861 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
862 DEFPARAM (PARAM_LTO_PARTITIONS, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
863 "lto-partitions", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
864 "Number of paritions program should be split to", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
865 32, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
866 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
867 DEFPARAM (MIN_PARTITION_SIZE, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
868 "lto-min-partition", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
869 "Size of minimal paritition for WHOPR (in estimated instructions)", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
870 1000, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
871 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
872 /* Diagnostic parameters. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
873 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
874 DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP, |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
875 "cxx-max-namespaces-for-diagnostic-help", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
876 "Maximum number of namespaces to search for alternatives when " |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
877 "name lookup fails", |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
878 1000, 0, 0) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
879 |
| 0 | 880 /* |
| 881 Local variables: | |
| 882 mode:c | |
| 883 End: | |
| 884 */ |