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