Mercurial > hg > CbC > CbC_gcc
annotate gcc/params.def @ 131:84e7813d76e9
gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 07:37:49 +0900 |
| parents | 04ced10e8804 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* params.def - Run-time parameters. |
| 131 | 2 Copyright (C) 2001-2018 Free Software Foundation, Inc. |
| 0 | 3 Written by Mark Mitchell <mark@codesourcery.com>. |
| 4 | |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 20 | |
| 21 /* This file contains definitions for language-independent | |
| 22 parameters. The DEFPARAM macro takes 6 arguments: | |
| 23 | |
| 24 - The enumeral corresponding to this parameter. | |
| 25 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
26 - The name that can be used to set this parameter using the |
| 0 | 27 command-line option `--param <name>=<value>'. |
| 28 | |
| 29 - A help string explaining how the parameter is used. | |
| 30 | |
| 31 - A default value for the parameter. | |
| 32 | |
| 33 - The minimum acceptable value for the parameter. | |
| 34 | |
| 35 - The maximum acceptable value for the parameter (if greater than | |
| 36 the minimum). | |
| 37 | |
| 111 | 38 The DEFPARAMENUM<N> macro is similar, but instead of the minumum and maximum |
| 39 arguments, it contains a list of <N> allowed strings, corresponding to | |
| 40 integer values 0..<N>-1. Note that the default argument needs to be | |
| 41 specified as one of the allowed strings, rather than an integer value. | |
| 0 | 42 |
| 111 | 43 Be sure to add an entry to invoke.texi summarizing the parameter. */ |
| 0 | 44 |
| 45 /* When branch is predicted to be taken with probability lower than this | |
| 46 threshold (in percent), then it is considered well predictable. */ | |
| 47 DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME, | |
| 48 "predictable-branch-outcome", | |
| 111 | 49 "Maximal estimated outcome of branch considered predictable.", |
| 0 | 50 2, 0, 50) |
| 51 | |
| 111 | 52 DEFPARAM (PARAM_INLINE_MIN_SPEEDUP, |
| 53 "inline-min-speedup", | |
| 54 "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.", | |
| 131 | 55 15, 0, 0) |
| 111 | 56 |
| 0 | 57 /* The single function inlining limit. This is the maximum size |
| 58 of a function counted in internal gcc instructions (not in | |
| 59 real machine instructions) that is eligible for inlining | |
| 60 by the tree inliner. | |
| 131 | 61 The default value is 400. |
| 0 | 62 Only functions marked inline (or methods defined in the class |
| 63 definition for C++) are affected by this. | |
| 64 There are more restrictions to inlining: If inlined functions | |
| 65 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
|
66 counted and once the recursive inline limit (see |
| 0 | 67 "max-inline-insns" parameter) is exceeded, the acceptable size |
| 68 gets decreased. */ | |
| 69 DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE, | |
| 70 "max-inline-insns-single", | |
| 111 | 71 "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
|
72 400, 0, 0) |
| 0 | 73 |
| 74 /* The single function inlining limit for functions that are | |
| 75 inlined by virtue of -finline-functions (-O3). | |
| 76 This limit should be chosen to be below or equal to the limit | |
| 77 that is applied to functions marked inlined (or defined in the | |
| 78 class declaration in C++) given by the "max-inline-insns-single" | |
| 79 parameter. | |
| 131 | 80 The default value is 30. */ |
| 0 | 81 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, |
| 82 "max-inline-insns-auto", | |
| 111 | 83 "The maximum number of instructions when automatically inlining.", |
| 131 | 84 30, 0, 0) |
| 0 | 85 |
| 86 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, | |
| 87 "max-inline-insns-recursive", | |
| 111 | 88 "The maximum number of instructions inline function can grow to via recursive inlining.", |
| 0 | 89 450, 0, 0) |
| 90 | |
| 91 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO, | |
| 92 "max-inline-insns-recursive-auto", | |
| 111 | 93 "The maximum number of instructions non-inline function can grow to via recursive inlining.", |
| 0 | 94 450, 0, 0) |
| 95 | |
| 96 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH, | |
| 97 "max-inline-recursive-depth", | |
| 111 | 98 "The maximum depth of recursive inlining for inline functions.", |
| 0 | 99 8, 0, 0) |
| 100 | |
| 101 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO, | |
| 102 "max-inline-recursive-depth-auto", | |
| 111 | 103 "The maximum depth of recursive inlining for non-inline functions.", |
| 0 | 104 8, 0, 0) |
| 105 | |
| 106 DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY, | |
| 107 "min-inline-recursive-probability", | |
| 111 | 108 "Inline recursively only when the probability of call being executed exceeds the parameter.", |
| 0 | 109 10, 0, 0) |
| 110 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
111 /* 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
|
112 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
|
113 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
|
114 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
|
115 "max-early-inliner-iterations", |
| 111 | 116 "The maximum number of nested indirect inlining performed by early inliner.", |
| 117 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
|
118 |
|
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
|
119 /* 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
|
120 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
|
121 "comdat-sharing-probability", |
| 111 | 122 "Probability that COMDAT function will be shared with different compilation unit.", |
|
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
|
123 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
|
124 |
|
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 /* 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
|
126 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
|
127 "partial-inlining-entry-probability", |
| 111 | 128 "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen.", |
| 129 70, 0, 100) | |
|
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
|
130 |
| 0 | 131 /* Limit the number of expansions created by the variable expansion |
| 132 optimization to avoid register pressure. */ | |
| 133 DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS, | |
| 134 "max-variable-expansions-in-unroller", | |
| 111 | 135 "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling.", |
| 0 | 136 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
|
137 |
| 0 | 138 /* Limit loop autovectorization to loops with large enough iteration count. */ |
| 139 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, | |
| 140 "min-vect-loop-bound", | |
| 111 | 141 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.", |
| 131 | 142 0, 0, 0) |
| 0 | 143 |
| 144 /* The maximum number of instructions to consider when looking for an | |
| 145 instruction to fill a delay slot. If more than this arbitrary | |
| 146 number of instructions is searched, the time savings from filling | |
| 147 the delay slot will be minimal so stop searching. Increasing | |
| 148 values mean more aggressive optimization, making the compile time | |
| 149 increase with probably small improvement in executable run time. */ | |
| 150 DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH, | |
| 151 "max-delay-slot-insn-search", | |
| 111 | 152 "The maximum number of instructions to consider to fill a delay slot.", |
| 0 | 153 100, 0, 0) |
| 154 | |
| 155 /* When trying to fill delay slots, the maximum number of instructions | |
| 156 to consider when searching for a block with valid live register | |
| 157 information. Increasing this arbitrarily chosen value means more | |
| 158 aggressive optimization, increasing the compile time. This | |
| 159 parameter should be removed when the delay slot code is rewritten | |
| 160 to maintain the control-flow graph. */ | |
| 161 DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH, | |
| 162 "max-delay-slot-live-search", | |
| 111 | 163 "The maximum number of instructions to consider to find accurate live register information.", |
| 0 | 164 333, 0, 0) |
| 165 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
166 /* This parameter limits the number of branch elements that the |
| 0 | 167 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
|
168 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
|
169 can generate lists containing many 1000's of dependencies. Generally |
| 0 | 170 the compiler either uses all available memory, or runs for far too long. */ |
| 171 DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH, | |
| 172 "max-pending-list-length", | |
| 111 | 173 "The maximum length of scheduling's pending operations list.", |
| 0 | 174 32, 0, 0) |
| 175 | |
| 111 | 176 /* This parameter limits the number of backtracking attempts when using the |
| 177 haifa scheduler for modulo scheduling. */ | |
| 178 DEFPARAM(PARAM_MAX_MODULO_BACKTRACK_ATTEMPTS, | |
| 179 "max-modulo-backtrack-attempts", | |
| 180 "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop.", | |
| 181 40, 0, 0) | |
| 182 | |
| 0 | 183 DEFPARAM(PARAM_LARGE_FUNCTION_INSNS, |
| 184 "large-function-insns", | |
| 111 | 185 "The size of function body to be considered large.", |
| 0 | 186 2700, 0, 0) |
| 187 DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH, | |
| 188 "large-function-growth", | |
| 111 | 189 "Maximal growth due to inlining of large function (in percent).", |
| 0 | 190 100, 0, 0) |
| 191 DEFPARAM(PARAM_LARGE_UNIT_INSNS, | |
| 192 "large-unit-insns", | |
| 111 | 193 "The size of translation unit to be considered large.", |
| 0 | 194 10000, 0, 0) |
| 195 DEFPARAM(PARAM_INLINE_UNIT_GROWTH, | |
| 196 "inline-unit-growth", | |
| 111 | 197 "How much can given compilation unit grow because of the inlining (in percent).", |
| 198 20, 0, 0) | |
| 0 | 199 DEFPARAM(PARAM_IPCP_UNIT_GROWTH, |
| 200 "ipcp-unit-growth", | |
| 111 | 201 "How much can given compilation unit grow because of the interprocedural constant propagation (in percent).", |
| 0 | 202 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
|
203 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
|
204 "early-inlining-insns", |
| 111 | 205 "Maximal estimated growth of function body caused by early inlining of single call.", |
| 206 14, 0, 0) | |
| 0 | 207 DEFPARAM(PARAM_LARGE_STACK_FRAME, |
| 208 "large-stack-frame", | |
| 111 | 209 "The size of stack frame to be considered large.", |
| 0 | 210 256, 0, 0) |
| 211 DEFPARAM(PARAM_STACK_FRAME_GROWTH, | |
| 212 "large-stack-frame-growth", | |
| 111 | 213 "Maximal stack frame growth due to inlining (in percent).", |
| 0 | 214 1000, 0, 0) |
| 215 | |
| 131 | 216 /* Keep these up to date with those in configure.ac. */ |
| 111 | 217 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE, |
| 218 "stack-clash-protection-guard-size", | |
| 131 | 219 "Size of the stack guard expressed as a power of two in bytes.", |
| 111 | 220 12, 12, 30) |
| 221 | |
| 222 DEFPARAM(PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL, | |
| 223 "stack-clash-protection-probe-interval", | |
| 131 | 224 "Interval in which to probe the stack expressed as a power of two in bytes.", |
| 111 | 225 12, 10, 16) |
| 226 | |
| 0 | 227 /* The GCSE optimization will be disabled if it would require |
| 228 significantly more memory than this value. */ | |
| 229 DEFPARAM(PARAM_MAX_GCSE_MEMORY, | |
| 230 "max-gcse-memory", | |
| 111 | 231 "The maximum amount of memory to be allocated by GCSE.", |
| 232 128 * 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
|
233 |
|
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
|
234 /* 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
|
235 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
|
236 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
|
237 "max-gcse-insertion-ratio", |
| 111 | 238 "The maximum ratio of insertions to deletions of expressions in GCSE.", |
|
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
|
239 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
|
240 |
| 0 | 241 /* This is the threshold ratio when to perform partial redundancy |
| 242 elimination after reload. We perform partial redundancy elimination | |
| 243 when the following holds: | |
| 244 (Redundant load execution count) | |
| 245 ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION | |
| 246 (Added loads execution count) */ | |
| 247 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION, | |
| 248 "gcse-after-reload-partial-fraction", | |
| 111 | 249 "The threshold ratio for performing partial redundancy elimination after reload.", |
| 0 | 250 3, 0, 0) |
| 251 /* This is the threshold ratio of the critical edges execution count compared to | |
| 252 the redundant loads execution count that permits performing the load | |
| 253 redundancy elimination in gcse after reload. */ | |
| 254 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION, | |
| 255 "gcse-after-reload-critical-fraction", | |
| 111 | 256 "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload.", |
| 0 | 257 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
|
258 |
|
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 /* 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
|
260 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
|
261 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
|
262 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
|
263 "gcse-cost-distance-ratio", |
| 111 | 264 "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations.", |
|
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
|
265 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
|
266 /* 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
|
267 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
|
268 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
|
269 "gcse-unrestricted-cost", |
| 111 | 270 "Cost at which GCSE optimizations will not constraint the distance an expression can travel.", |
|
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
|
271 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
|
272 |
|
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
|
273 /* 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
|
274 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
|
275 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
|
276 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
|
277 "max-hoist-depth", |
| 111 | 278 "Maximum depth of search in the dominator tree for expressions to hoist.", |
|
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
|
279 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
|
280 |
| 111 | 281 |
| 282 /* When synthesizing expnonentiation by a real constant operations using square | |
| 283 roots, this controls how deep sqrt chains we are willing to generate. */ | |
| 284 DEFPARAM(PARAM_MAX_POW_SQRT_DEPTH, | |
| 285 "max-pow-sqrt-depth", | |
| 286 "Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant.", | |
| 287 5, 1, 32) | |
| 288 | |
| 0 | 289 /* This parameter limits the number of insns in a loop that will be unrolled, |
| 290 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
|
291 |
| 0 | 292 This limit should be at most half of the peeling limits: loop unroller |
| 293 decides to not unroll loops that iterate fewer than 2*number of allowed | |
| 294 unrollings and thus we would have loops that are neither peeled or unrolled | |
| 295 otherwise. */ | |
| 296 DEFPARAM(PARAM_MAX_UNROLLED_INSNS, | |
| 297 "max-unrolled-insns", | |
| 111 | 298 "The maximum number of instructions to consider to unroll in a loop.", |
| 0 | 299 200, 0, 0) |
| 300 /* This parameter limits how many times the loop is unrolled depending | |
| 301 on number of insns really executed in each iteration. */ | |
| 302 DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS, | |
| 303 "max-average-unrolled-insns", | |
| 111 | 304 "The maximum number of instructions to consider to unroll in a loop on average.", |
| 0 | 305 80, 0, 0) |
| 306 /* The maximum number of unrollings of a single loop. */ | |
| 307 DEFPARAM(PARAM_MAX_UNROLL_TIMES, | |
| 308 "max-unroll-times", | |
| 111 | 309 "The maximum number of unrollings of a single loop.", |
| 0 | 310 8, 0, 0) |
| 311 /* The maximum number of insns of a peeled loop. */ | |
| 312 DEFPARAM(PARAM_MAX_PEELED_INSNS, | |
| 313 "max-peeled-insns", | |
| 111 | 314 "The maximum number of insns of a peeled loop.", |
| 315 100, 0, 0) | |
| 0 | 316 /* The maximum number of peelings of a single loop. */ |
| 317 DEFPARAM(PARAM_MAX_PEEL_TIMES, | |
| 318 "max-peel-times", | |
| 111 | 319 "The maximum number of peelings of a single loop.", |
| 0 | 320 16, 0, 0) |
| 111 | 321 /* The maximum number of peelings of a single loop that is peeled completely. */ |
| 322 DEFPARAM(PARAM_MAX_PEEL_BRANCHES, | |
| 323 "max-peel-branches", | |
| 324 "The maximum number of branches on the path through the peeled sequence.", | |
| 325 32, 0, 0) | |
| 0 | 326 /* The maximum number of insns of a peeled loop. */ |
| 327 DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS, | |
| 328 "max-completely-peeled-insns", | |
| 111 | 329 "The maximum number of insns of a completely peeled loop.", |
| 330 200, 0, 0) | |
| 0 | 331 /* The maximum number of peelings of a single loop that is peeled completely. */ |
| 332 DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES, | |
| 333 "max-completely-peel-times", | |
| 111 | 334 "The maximum number of peelings of a single loop that is peeled completely.", |
| 0 | 335 16, 0, 0) |
| 336 /* The maximum number of insns of a peeled loop that rolls only once. */ | |
| 337 DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS, | |
| 338 "max-once-peeled-insns", | |
| 111 | 339 "The maximum number of insns of a peeled loop that rolls only once.", |
| 0 | 340 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
|
341 /* 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
|
342 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
|
343 "max-completely-peel-loop-nest-depth", |
| 111 | 344 "The maximum depth of a loop nest we completely peel.", |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
345 8, 0, 0) |
| 0 | 346 |
| 347 /* The maximum number of insns of an unswitched loop. */ | |
| 348 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS, | |
| 349 "max-unswitch-insns", | |
| 111 | 350 "The maximum number of insns of an unswitched loop.", |
| 0 | 351 50, 0, 0) |
| 352 /* The maximum level of recursion in unswitch_single_loop. */ | |
| 353 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, | |
| 354 "max-unswitch-level", | |
| 111 | 355 "The maximum number of unswitchings in a single loop.", |
| 0 | 356 3, 0, 0) |
| 357 | |
| 131 | 358 /* The maximum number of insns in loop header duplicated by the copy loop |
| 111 | 359 headers pass. */ |
| 360 DEFPARAM(PARAM_MAX_LOOP_HEADER_INSNS, | |
| 361 "max-loop-header-insns", | |
| 131 | 362 "The maximum number of insns in loop header duplicated by the copy loop headers pass.", |
| 111 | 363 20, 0, 0) |
| 364 | |
| 0 | 365 /* The maximum number of iterations of a loop the brute force algorithm |
| 366 for analysis of # of iterations of the loop tries to evaluate. */ | |
| 367 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, | |
| 368 "max-iterations-to-track", | |
| 111 | 369 "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates.", |
| 0 | 370 1000, 0, 0) |
| 371 /* A cutoff to avoid costly computations of the number of iterations in | |
| 372 the doloop transformation. */ | |
| 373 DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST, | |
| 374 "max-iterations-computation-cost", | |
| 111 | 375 "Bound on the cost of an expression to compute the number of iterations.", |
| 0 | 376 10, 0, 0) |
| 377 | |
| 378 /* This parameter is used to tune SMS MAX II calculations. */ | |
| 379 DEFPARAM(PARAM_SMS_MAX_II_FACTOR, | |
| 380 "sms-max-ii-factor", | |
| 111 | 381 "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop.", |
| 0 | 382 100, 0, 0) |
| 111 | 383 /* The minimum value of stage count that swing modulo scheduler will generate. */ |
| 384 DEFPARAM(PARAM_SMS_MIN_SC, | |
| 385 "sms-min-sc", | |
| 386 "The minimum value of stage count that swing modulo scheduler will generate.", | |
| 387 2, 1, 1) | |
| 0 | 388 DEFPARAM(PARAM_SMS_DFA_HISTORY, |
| 389 "sms-dfa-history", | |
| 111 | 390 "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA.", |
| 0 | 391 0, 0, 0) |
| 392 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, | |
| 393 "sms-loop-average-count-threshold", | |
| 111 | 394 "A threshold on the average loop count considered by the swing modulo scheduler.", |
| 0 | 395 0, 0, 0) |
| 396 | |
| 131 | 397 DEFPARAM(HOT_BB_COUNT_FRACTION, |
| 398 "hot-bb-count-fraction", | |
| 399 "Select fraction of the maximal count of repetitions of basic block in program given basic " | |
| 400 "block needs to have to be considered hot (used in non-LTO mode)", | |
| 401 10000, 0, 0) | |
| 111 | 402 DEFPARAM(HOT_BB_COUNT_WS_PERMILLE, |
| 403 "hot-bb-count-ws-permille", | |
| 404 "A basic block profile count is considered hot if it contributes to " | |
| 131 | 405 "the given permillage of the entire profiled execution (used in LTO mode).", |
| 111 | 406 999, 0, 1000) |
| 0 | 407 DEFPARAM(HOT_BB_FREQUENCY_FRACTION, |
| 408 "hot-bb-frequency-fraction", | |
| 111 | 409 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.", |
| 0 | 410 1000, 0, 0) |
| 411 | |
| 111 | 412 DEFPARAM(UNLIKELY_BB_COUNT_FRACTION, |
| 413 "unlikely-bb-count-fraction", | |
| 414 "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely.", | |
| 415 20, 1, 10000) | |
| 416 | |
| 0 | 417 DEFPARAM (PARAM_ALIGN_THRESHOLD, |
| 418 "align-threshold", | |
| 111 | 419 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.", |
| 420 100, 1, 0) | |
| 0 | 421 |
| 422 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, | |
| 423 "align-loop-iterations", | |
| 131 | 424 "Loops iterating at least selected number of iterations will get " |
| 425 "loop alignment.", 4, 0, 0) | |
| 0 | 426 |
| 427 /* For guessed profiles, the loops having unknown number of iterations | |
| 428 are predicted to iterate relatively few (10) times at average. | |
| 429 For functions containing one loop with large known number of iterations | |
| 430 and other loops having unbounded loops we would end up predicting all | |
| 431 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
|
432 flatten the profile. |
| 0 | 433 |
| 434 We need to cut the maximal predicted iterations to large enough iterations | |
| 111 | 435 so the loop appears important, but safely within maximum hotness |
| 0 | 436 range. */ |
| 437 | |
| 438 DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS, | |
| 439 "max-predicted-iterations", | |
| 111 | 440 "The maximum number of loop iterations we predict statically.", |
| 0 | 441 100, 0, 0) |
| 111 | 442 |
| 443 /* This parameter controls the probability of builtin_expect. The default | |
| 444 value is 90%. This empirical value is obtained through the weighted | |
| 445 probability of FDO counters (with the FDO count value as the weight) | |
| 446 in some real world programs: | |
| 447 (1) Google performance test benchmarks: the probability is 0.9081. | |
| 448 (2) Linux 3.3 kernel running Google search workload: the probability | |
| 449 is 0.8717. */ | |
| 450 | |
| 451 DEFPARAM(BUILTIN_EXPECT_PROBABILITY, | |
| 452 "builtin-expect-probability", | |
| 453 "Set the estimated probability in percentage for builtin expect. The default value is 90% probability.", | |
| 454 90, 0, 100) | |
| 131 | 455 DEFPARAM(BUILTIN_STRING_CMP_INLINE_LENGTH, |
| 456 "builtin-string-cmp-inline-length", | |
| 457 "The maximum length of a constant string for a builtin string cmp call eligible for inlining. The default value is 3.", | |
| 458 3, 0, 100) | |
| 0 | 459 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, |
| 460 "tracer-dynamic-coverage-feedback", | |
| 111 | 461 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.", |
| 0 | 462 95, 0, 100) |
| 463 DEFPARAM(TRACER_DYNAMIC_COVERAGE, | |
| 464 "tracer-dynamic-coverage", | |
| 111 | 465 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available.", |
| 0 | 466 75, 0, 100) |
| 467 DEFPARAM(TRACER_MAX_CODE_GROWTH, | |
| 468 "tracer-max-code-growth", | |
| 111 | 469 "Maximal code growth caused by tail duplication (in percent).", |
| 0 | 470 100, 0, 0) |
| 471 DEFPARAM(TRACER_MIN_BRANCH_RATIO, | |
| 472 "tracer-min-branch-ratio", | |
| 111 | 473 "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent).", |
| 0 | 474 10, 0, 100) |
| 475 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK, | |
| 476 "tracer-min-branch-probability-feedback", | |
| 111 | 477 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available.", |
| 0 | 478 80, 0, 100) |
| 479 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, | |
| 480 "tracer-min-branch-probability", | |
| 111 | 481 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available.", |
| 0 | 482 50, 0, 100) |
| 483 | |
| 484 /* The maximum number of incoming edges to consider for crossjumping. */ | |
| 485 DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES, | |
| 486 "max-crossjump-edges", | |
| 111 | 487 "The maximum number of incoming edges to consider for crossjumping.", |
| 0 | 488 100, 0, 0) |
| 489 | |
| 490 /* The minimum number of matching instructions to consider for crossjumping. */ | |
| 491 DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS, | |
| 492 "min-crossjump-insns", | |
| 111 | 493 "The minimum number of matching instructions to consider for crossjumping.", |
| 494 5, 1, 0) | |
| 0 | 495 |
| 496 /* The maximum number expansion factor when copying basic blocks. */ | |
| 497 DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS, | |
| 498 "max-grow-copy-bb-insns", | |
| 111 | 499 "The maximum expansion factor when copying basic blocks.", |
| 0 | 500 8, 0, 0) |
| 501 | |
| 502 /* The maximum number of insns to duplicate when unfactoring computed gotos. */ | |
| 503 DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS, | |
| 504 "max-goto-duplication-insns", | |
| 111 | 505 "The maximum number of insns to duplicate when unfactoring computed gotos.", |
| 0 | 506 8, 0, 0) |
| 507 | |
| 508 /* The maximum length of path considered in cse. */ | |
| 509 DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH, | |
| 510 "max-cse-path-length", | |
| 111 | 511 "The maximum length of path considered in cse.", |
| 512 10, 1, 0) | |
| 0 | 513 DEFPARAM(PARAM_MAX_CSE_INSNS, |
| 514 "max-cse-insns", | |
| 111 | 515 "The maximum instructions CSE process before flushing.", |
| 0 | 516 1000, 0, 0) |
| 517 | |
| 518 /* The cost of expression in loop invariant motion that is considered | |
| 519 expensive. */ | |
| 520 DEFPARAM(PARAM_LIM_EXPENSIVE, | |
| 521 "lim-expensive", | |
| 111 | 522 "The minimum cost of an expensive expression in the loop invariant motion.", |
| 0 | 523 20, 0, 0) |
| 524 | |
| 525 /* Bound on number of candidates for induction variables below that | |
| 526 all candidates are considered for each use in induction variable | |
| 527 optimizations. */ | |
| 528 | |
| 529 DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, | |
| 530 "iv-consider-all-candidates-bound", | |
| 111 | 531 "Bound on number of candidates below that all candidates are considered in iv optimizations.", |
| 532 40, 0, 0) | |
| 0 | 533 |
| 534 /* The induction variable optimizations give up on loops that contain more | |
| 535 induction variable uses. */ | |
| 536 | |
| 537 DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES, | |
| 538 "iv-max-considered-uses", | |
| 111 | 539 "Bound on number of iv uses in loop optimized in iv optimizations.", |
| 0 | 540 250, 0, 0) |
| 541 | |
| 542 /* If there are at most this number of ivs in the set, try removing unnecessary | |
| 543 ivs from the set always. */ | |
| 544 | |
| 545 DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, | |
| 546 "iv-always-prune-cand-set-bound", | |
| 111 | 547 "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization.", |
| 0 | 548 10, 0, 0) |
| 549 | |
| 111 | 550 DEFPARAM(PARAM_AVG_LOOP_NITER, |
| 551 "avg-loop-niter", | |
| 552 "Average number of iterations of a loop.", | |
| 553 10, 1, 0) | |
| 554 | |
| 555 DEFPARAM(PARAM_DSE_MAX_OBJECT_SIZE, | |
| 556 "dse-max-object-size", | |
| 557 "Maximum size (in bytes) of objects tracked bytewise by dead store elimination.", | |
| 558 256, 0, 0) | |
| 559 | |
| 131 | 560 DEFPARAM(PARAM_DSE_MAX_ALIAS_QUERIES_PER_STORE, |
| 561 "dse-max-alias-queries-per-store", | |
| 562 "Maximum number of queries into the alias oracle per store.", | |
| 563 256, 0, 0) | |
| 564 | |
| 0 | 565 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, |
| 566 "scev-max-expr-size", | |
| 111 | 567 "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
|
568 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
|
569 |
|
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
|
570 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
|
571 "scev-max-expr-complexity", |
| 111 | 572 "Bound on the complexity of the expressions 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
|
573 10, 0, 0) |
| 0 | 574 |
| 111 | 575 DEFPARAM (PARAM_MAX_TREE_IF_CONVERSION_PHI_ARGS, |
| 576 "max-tree-if-conversion-phi-args", | |
| 577 "Maximum number of arguments in a PHI supported by TREE if-conversion " | |
| 578 "unless the loop is marked with simd pragma.", | |
| 579 4, 2, 0) | |
| 0 | 580 |
| 581 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS, | |
| 582 "vect-max-version-for-alignment-checks", | |
| 111 | 583 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check.", |
| 0 | 584 6, 0, 0) |
| 585 | |
| 586 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, | |
| 587 "vect-max-version-for-alias-checks", | |
| 111 | 588 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check.", |
| 0 | 589 10, 0, 0) |
| 590 | |
| 111 | 591 DEFPARAM(PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT, |
| 592 "vect-max-peeling-for-alignment", | |
| 593 "Maximum number of loop peels to enhance alignment of data references in a loop.", | |
| 594 -1, -1, 64) | |
| 595 | |
| 0 | 596 DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS, |
| 597 "max-cselib-memory-locations", | |
| 111 | 598 "The maximum memory locations recorded by cselib.", |
| 0 | 599 500, 0, 0) |
| 600 | |
| 601 #ifdef ENABLE_GC_ALWAYS_COLLECT | |
| 602 # define GGC_MIN_EXPAND_DEFAULT 0 | |
| 603 # define GGC_MIN_HEAPSIZE_DEFAULT 0 | |
| 604 #else | |
| 605 # define GGC_MIN_EXPAND_DEFAULT 30 | |
| 606 # define GGC_MIN_HEAPSIZE_DEFAULT 4096 | |
| 607 #endif | |
| 608 | |
| 609 DEFPARAM(GGC_MIN_EXPAND, | |
| 610 "ggc-min-expand", | |
| 111 | 611 "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap.", |
| 0 | 612 GGC_MIN_EXPAND_DEFAULT, 0, 0) |
| 613 | |
| 614 DEFPARAM(GGC_MIN_HEAPSIZE, | |
| 615 "ggc-min-heapsize", | |
| 111 | 616 "Minimum heap size before we start collecting garbage, in kilobytes.", |
| 0 | 617 GGC_MIN_HEAPSIZE_DEFAULT, 0, 0) |
| 618 | |
| 619 #undef GGC_MIN_EXPAND_DEFAULT | |
| 620 #undef GGC_MIN_HEAPSIZE_DEFAULT | |
| 621 | |
| 622 DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS, | |
| 623 "max-reload-search-insns", | |
| 111 | 624 "The maximum number of instructions to search backward when looking for equivalent reload.", |
| 0 | 625 100, 0, 0) |
| 626 | |
| 111 | 627 DEFPARAM(PARAM_SINK_FREQUENCY_THRESHOLD, |
| 628 "sink-frequency-threshold", | |
| 629 "Target block's relative execution frequency (as a percentage) required to sink a statement.", | |
| 630 75, 0, 100) | |
| 631 | |
| 0 | 632 DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS, |
| 633 "max-sched-region-blocks", | |
| 111 | 634 "The maximum number of blocks in a region to be considered for interblock scheduling.", |
| 0 | 635 10, 0, 0) |
| 636 | |
| 637 DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS, | |
| 638 "max-sched-region-insns", | |
| 111 | 639 "The maximum number of insns in a region to be considered for interblock scheduling.", |
| 0 | 640 100, 0, 0) |
| 641 | |
| 642 DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS, | |
| 643 "max-pipeline-region-blocks", | |
| 111 | 644 "The maximum number of blocks in a region to be considered for interblock scheduling.", |
| 0 | 645 15, 0, 0) |
| 646 | |
| 647 DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS, | |
| 648 "max-pipeline-region-insns", | |
| 111 | 649 "The maximum number of insns in a region to be considered for interblock scheduling.", |
| 0 | 650 200, 0, 0) |
| 651 | |
| 652 DEFPARAM(PARAM_MIN_SPEC_PROB, | |
| 653 "min-spec-prob", | |
| 111 | 654 "The minimum probability of reaching a source block for interblock speculative scheduling.", |
| 0 | 655 40, 0, 0) |
| 656 | |
| 657 DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, | |
| 658 "max-sched-extend-regions-iters", | |
| 111 | 659 "The maximum number of iterations through CFG to extend regions.", |
| 0 | 660 0, 0, 0) |
| 661 | |
| 662 DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY, | |
| 663 "max-sched-insn-conflict-delay", | |
| 111 | 664 "The maximum conflict delay for an insn to be considered for speculative motion.", |
| 0 | 665 3, 1, 10) |
| 666 | |
| 667 DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF, | |
| 668 "sched-spec-prob-cutoff", | |
| 669 "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.", | |
| 670 40, 0, 100) | |
| 671 | |
| 111 | 672 DEFPARAM(PARAM_SCHED_STATE_EDGE_PROB_CUTOFF, |
| 673 "sched-state-edge-prob-cutoff", | |
| 674 "The minimum probability an edge must have for the scheduler to save its state across it.", | |
| 675 10, 0, 100) | |
| 676 | |
| 0 | 677 DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD, |
| 678 "selsched-max-lookahead", | |
| 111 | 679 "The maximum size of the lookahead window of selective scheduling.", |
| 0 | 680 50, 0, 0) |
| 681 | |
| 682 DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES, | |
| 683 "selsched-max-sched-times", | |
| 111 | 684 "Maximum number of times that an insn could be scheduled.", |
| 685 2, 1, 0) | |
| 0 | 686 |
| 687 DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME, | |
| 688 "selsched-insns-to-rename", | |
| 111 | 689 "Maximum number of instructions in the ready list that are considered eligible for renaming.", |
| 0 | 690 2, 0, 0) |
| 691 | |
| 692 DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST, | |
| 693 "sched-mem-true-dep-cost", | |
| 111 | 694 "Minimal distance between possibly conflicting store and load.", |
| 0 | 695 1, 0, 0) |
| 696 | |
| 111 | 697 DEFPARAM (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH, |
| 698 "sched-autopref-queue-depth", | |
| 699 "Hardware autoprefetcher scheduler model control flag. Number of lookahead cycles the model looks into; at '0' only enable instruction sorting heuristic. Disabled by default.", | |
| 700 -1, 0, 0) | |
| 701 | |
| 0 | 702 DEFPARAM(PARAM_MAX_LAST_VALUE_RTL, |
| 703 "max-last-value-rtl", | |
| 111 | 704 "The maximum number of RTL nodes that can be recorded as combiner's last value.", |
| 0 | 705 10000, 0, 0) |
| 706 | |
| 111 | 707 DEFPARAM(PARAM_MAX_COMBINE_INSNS, |
| 708 "max-combine-insns", | |
| 709 "The maximum number of insns combine tries to combine.", | |
| 710 4, 2, 4) | |
| 711 | |
| 0 | 712 /* INTEGER_CST nodes are shared for values [{-1,0} .. N) for |
| 713 {signed,unsigned} integral types. This determines N. | |
| 111 | 714 Experimentation shows 251 to be a good value that generates the |
| 715 least amount of garbage for allocating the TREE_VEC storage. */ | |
| 0 | 716 DEFPARAM (PARAM_INTEGER_SHARE_LIMIT, |
| 717 "integer-share-limit", | |
| 111 | 718 "The upper bound for sharing integer constants.", |
| 719 251, 2, 2) | |
| 0 | 720 |
| 721 DEFPARAM (PARAM_SSP_BUFFER_SIZE, | |
| 722 "ssp-buffer-size", | |
| 111 | 723 "The lower bound for a buffer to be considered for stack smashing protection.", |
| 0 | 724 8, 1, 0) |
| 725 | |
| 111 | 726 DEFPARAM (PARAM_MIN_SIZE_FOR_STACK_SHARING, |
| 727 "min-size-for-stack-sharing", | |
| 728 "The minimum size of variables taking part in stack slot sharing " | |
| 729 "when not optimizing.", | |
| 730 32, 0, 0) | |
| 731 | |
| 0 | 732 /* When we thread through a block we have to make copies of the |
| 733 statements within the block. Clearly for large blocks the code | |
| 734 duplication is bad. | |
| 735 | |
| 736 PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number | |
| 737 of statements and PHI nodes allowed in a block which is going to | |
| 738 be duplicated for thread jumping purposes. | |
| 739 | |
| 740 Some simple analysis showed that more than 99% of the jump | |
| 741 threading opportunities are for blocks with less than 15 | |
| 742 statements. So we can get the benefits of jump threading | |
| 743 without excessive code bloat for pathological cases with the | |
| 744 throttle set at 15 statements. */ | |
| 745 DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS, | |
| 746 "max-jump-thread-duplication-stmts", | |
| 111 | 747 "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps.", |
| 0 | 748 15, 0, 0) |
| 749 | |
| 750 /* 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
|
751 will stop trying to treat it in a field-sensitive manner. |
| 0 | 752 There are programs out there with thousands of fields per structure, and handling them |
| 753 field-sensitively is not worth the cost. */ | |
| 754 DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE, | |
| 755 "max-fields-for-field-sensitive", | |
| 111 | 756 "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable.", |
| 0 | 757 0, 0, 0) |
| 758 | |
| 759 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, | |
| 760 "max-sched-ready-insns", | |
| 111 | 761 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.", |
| 131 | 762 100, 1, 0) |
| 0 | 763 |
| 111 | 764 /* This is the maximum number of active local stores RTL DSE will consider. */ |
| 765 DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES, | |
| 766 "max-dse-active-local-stores", | |
| 767 "Maximum number of active local stores in RTL dead store elimination.", | |
| 768 5000, 0, 0) | |
| 769 | |
| 0 | 770 /* Prefetching and cache-optimizations related parameters. Default values are |
| 771 usually set by machine description. */ | |
| 772 | |
| 773 /* The number of insns executed before prefetch is completed. */ | |
| 774 | |
| 775 DEFPARAM (PARAM_PREFETCH_LATENCY, | |
| 776 "prefetch-latency", | |
| 111 | 777 "The number of insns executed before prefetch is completed.", |
| 0 | 778 200, 0, 0) |
| 779 | |
| 780 /* The number of prefetches that can run at the same time. */ | |
| 781 | |
| 782 DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES, | |
| 783 "simultaneous-prefetches", | |
| 111 | 784 "The number of prefetches that can run at the same time.", |
| 0 | 785 3, 0, 0) |
| 786 | |
| 787 /* The size of L1 cache in kB. */ | |
| 788 | |
| 789 DEFPARAM (PARAM_L1_CACHE_SIZE, | |
| 790 "l1-cache-size", | |
| 111 | 791 "The size of L1 cache.", |
| 0 | 792 64, 0, 0) |
| 793 | |
| 794 /* The size of L1 cache line in bytes. */ | |
| 795 | |
| 796 DEFPARAM (PARAM_L1_CACHE_LINE_SIZE, | |
| 797 "l1-cache-line-size", | |
| 111 | 798 "The size of L1 cache line.", |
| 0 | 799 32, 0, 0) |
| 800 | |
| 801 /* The size of L2 cache in kB. */ | |
| 802 | |
| 803 DEFPARAM (PARAM_L2_CACHE_SIZE, | |
| 804 "l2-cache-size", | |
| 111 | 805 "The size of L2 cache.", |
| 0 | 806 512, 0, 0) |
| 807 | |
| 131 | 808 /* Whether software prefetch hints should be issued for non-constant |
| 809 strides. */ | |
| 810 | |
| 811 DEFPARAM (PARAM_PREFETCH_DYNAMIC_STRIDES, | |
| 812 "prefetch-dynamic-strides", | |
| 813 "Whether software prefetch hints should be issued for non-constant " | |
| 814 "strides.", | |
| 815 1, 0, 1) | |
| 816 | |
| 817 /* The minimum constant stride beyond which we should use prefetch hints | |
| 818 for. */ | |
| 819 | |
| 820 DEFPARAM (PARAM_PREFETCH_MINIMUM_STRIDE, | |
| 821 "prefetch-minimum-stride", | |
| 822 "The minimum constant stride beyond which we should use prefetch " | |
| 823 "hints for.", | |
| 824 -1, 0, 0) | |
| 825 | |
| 826 /* Maximum number of statements in loop nest for loop interchange. */ | |
| 827 | |
| 828 DEFPARAM (PARAM_LOOP_INTERCHANGE_MAX_NUM_STMTS, | |
| 829 "loop-interchange-max-num-stmts", | |
| 830 "The maximum number of stmts in loop nest for loop interchange.", | |
| 831 64, 0, 0) | |
| 832 | |
| 833 /* Minimum stride ratio for loop interchange to be profitiable. */ | |
| 834 | |
| 835 DEFPARAM (PARAM_LOOP_INTERCHANGE_STRIDE_RATIO, | |
| 836 "loop-interchange-stride-ratio", | |
| 837 "The minimum stride ratio for loop interchange to be profitable.", | |
| 838 2, 0, 0) | |
| 839 | |
| 0 | 840 /* Whether we should use canonical types rather than deep "structural" |
| 841 type checking. Setting this value to 1 (the default) improves | |
| 842 compilation performance in the C++ and Objective-C++ front end; | |
| 843 this value should only be set to zero to work around bugs in the | |
| 844 canonical type system by disabling it. */ | |
| 845 | |
| 846 DEFPARAM (PARAM_USE_CANONICAL_TYPES, | |
| 847 "use-canonical-types", | |
| 111 | 848 "Whether to use canonical types.", |
| 0 | 849 1, 0, 1) |
| 850 | |
| 851 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, | |
| 852 "max-partial-antic-length", | |
| 111 | 853 "Maximum length of partial antic set when performing tree pre optimization.", |
| 0 | 854 100, 0, 0) |
| 855 | |
| 131 | 856 /* The following is used as a stop-gap limit for cases where really deep |
| 857 loop nests cause compile-time to blow up. If we hit this limit, | |
| 858 FRE and PRE will value-number outer loops (but the outermost) in a | |
| 859 loop nest non-optimistically. */ | |
| 0 | 860 |
| 131 | 861 DEFPARAM (PARAM_RPO_VN_MAX_LOOP_DEPTH, |
| 862 "rpo-vn-max-loop-depth", | |
| 863 "Maximum depth of a loop nest to fully value-number optimistically.", | |
| 864 7, 2, 0) | |
| 0 | 865 |
| 111 | 866 /* The following is used as a stop-gap limit for cases where really huge |
| 867 functions blow up compile-time use too much. It limits the number of | |
| 868 alias-queries we do for finding common subexpressions for memory loads and | |
| 869 stores. The number of alias-queries is otherwise limited by the number of | |
| 870 stores on paths to function entry. */ | |
| 871 | |
| 872 DEFPARAM (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS, | |
| 873 "sccvn-max-alias-queries-per-access", | |
| 874 "Maximum number of disambiguations to perform per memory access.", | |
| 875 1000, 0, 0) | |
| 876 | |
| 0 | 877 DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM, |
| 878 "ira-max-loops-num", | |
| 111 | 879 "Max loops number for regional RA.", |
| 0 | 880 100, 0, 0) |
| 881 | |
| 882 DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE, | |
| 883 "ira-max-conflict-table-size", | |
| 111 | 884 "Max size of conflict table in MB.", |
| 0 | 885 1000, 0, 0) |
| 886 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
887 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
|
888 "ira-loop-reserved-regs", |
| 111 | 889 "The number of registers in each class kept unused by loop invariant motion.", |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
890 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
|
891 |
| 111 | 892 DEFPARAM (PARAM_LRA_MAX_CONSIDERED_RELOAD_PSEUDOS, |
| 893 "lra-max-considered-reload-pseudos", | |
| 894 "The max number of reload pseudos which are considered during spilling a non-reload pseudo.", | |
| 895 500, 0, 0) | |
| 896 | |
| 897 DEFPARAM (PARAM_LRA_INHERITANCE_EBB_PROBABILITY_CUTOFF, | |
| 898 "lra-inheritance-ebb-probability-cutoff", | |
| 899 "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA.", | |
| 900 40, 0, 100) | |
| 901 | |
| 0 | 902 /* Switch initialization conversion will refuse to create arrays that are |
| 903 bigger than this parameter times the number of switch branches. */ | |
| 904 | |
| 905 DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO, | |
| 906 "switch-conversion-max-branch-ratio", | |
| 907 "The maximum ratio between array size and switch branches for " | |
| 111 | 908 "a switch conversion to take place.", |
| 0 | 909 8, 1, 0) |
| 910 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
911 /* 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
|
912 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
913 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
|
914 "loop-block-tile-size", |
| 131 | 915 "Size of tiles for loop blocking.", |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
916 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
|
917 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
918 /* 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
|
919 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
920 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
|
921 "graphite-max-nb-scop-params", |
| 131 | 922 "Maximum number of parameters in a SCoP.", |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
923 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
|
924 |
| 111 | 925 /* Maximal number of array references in a scop. */ |
| 926 | |
| 927 DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP, | |
| 928 "graphite-max-arrays-per-scop", | |
| 131 | 929 "Maximum number of arrays per scop.", |
| 111 | 930 100, 0, 0) |
| 931 | |
| 932 DEFPARAM (PARAM_MAX_ISL_OPERATIONS, | |
| 933 "max-isl-operations", | |
| 131 | 934 "Maximum number of isl operations, 0 means unlimited.", |
| 111 | 935 350000, 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
|
936 |
| 111 | 937 /* For testsuite purposes allow to check for codegen error handling. */ |
| 938 DEFPARAM (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS, | |
| 939 "graphite-allow-codegen-errors", | |
| 131 | 940 "Whether codegen errors should be ICEs when -fchecking.", |
| 111 | 941 0, 0, 1) |
| 942 | |
| 943 /* Avoid data dependence analysis on very large loops. */ | |
| 944 DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS, | |
| 945 "loop-max-datarefs-for-datadeps", | |
| 946 "Maximum number of datarefs in loop for building loop data dependencies.", | |
| 947 1000, 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
|
948 |
| 0 | 949 /* Avoid doing loop invariant motion on very large loops. */ |
| 950 | |
| 951 DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP, | |
| 952 "loop-invariant-max-bbs-in-loop", | |
| 111 | 953 "Max basic blocks number in loop for loop invariant motion.", |
| 0 | 954 10000, 0, 0) |
| 955 | |
| 111 | 956 /* When the parameter is 1, use the internal function id |
| 957 to look up for profile data. Otherwise, use a more stable | |
| 958 external id based on assembler name and source location. */ | |
| 959 DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID, | |
| 131 | 960 "profile-func-internal-id", |
| 961 "Use internal function id in profile lookup.", | |
| 962 0, 0, 1) | |
| 111 | 963 |
| 964 /* When the parameter is 1, track the most frequent N target | |
| 965 addresses in indirect-call profile. This disables | |
| 966 indirect_call_profiler_v2 which tracks single target. */ | |
| 967 DEFPARAM (PARAM_INDIR_CALL_TOPN_PROFILE, | |
| 131 | 968 "indir-call-topn-profile", |
| 969 "Track top N target addresses in indirect-call profile.", | |
| 970 0, 0, 1) | |
| 111 | 971 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
972 /* 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
|
973 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, |
| 131 | 974 "slp-max-insns-in-bb", |
| 975 "Maximum number of instructions in basic block to be considered for " | |
| 976 "SLP vectorization.", 1000, 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
|
977 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
978 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
|
979 "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
|
980 "Min. ratio of insns to prefetches to enable prefetching for " |
| 111 | 981 "a loop with an unknown trip count.", |
| 982 9, 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
|
983 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
984 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
|
985 "prefetch-min-insn-to-mem-ratio", |
| 111 | 986 "Min. ratio of insns to mem ops to enable prefetching in a loop.", |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
987 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
|
988 |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
989 /* 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
|
990 |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
991 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
|
992 "max-vartrack-size", |
| 111 | 993 "Max. size of var tracking hash tables.", |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
994 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
|
995 |
| 111 | 996 /* Set maximum recursion depth for var tracking expression expansion |
| 997 and resolution. */ | |
| 998 | |
| 999 DEFPARAM (PARAM_MAX_VARTRACK_EXPR_DEPTH, | |
| 1000 "max-vartrack-expr-depth", | |
| 1001 "Max. recursion depth for expanding var tracking expressions.", | |
| 1002 12, 0, 0) | |
| 1003 | |
| 1004 /* Set maximum length of value location list for which var tracking | |
| 1005 should add reverse operations. */ | |
| 1006 | |
| 1007 DEFPARAM (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE, | |
| 1008 "max-vartrack-reverse-op-size", | |
| 1009 "Max. size of loc list for which reverse ops should be added.", | |
| 1010 50, 0, 0) | |
| 1011 | |
| 131 | 1012 /* Set a threshold to discard debug markers (e.g. debug begin stmt |
| 1013 markers) when expanding a function to RTL, or inlining it into | |
| 1014 another function. */ | |
| 1015 | |
| 1016 DEFPARAM (PARAM_MAX_DEBUG_MARKER_COUNT, | |
| 1017 "max-debug-marker-count", | |
| 1018 "Max. count of debug markers to expand or inline.", | |
| 1019 100000, 0, 0) | |
| 1020 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1021 /* 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
|
1022 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1023 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
|
1024 "min-nondebug-insn-uid", |
| 111 | 1025 "The minimum UID to be used for a nondebug insn.", |
| 1026 0, 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
|
1027 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1028 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
|
1029 "ipa-sra-ptr-growth-factor", |
| 131 | 1030 "Maximum allowed growth of number and total size of new parameters " |
| 1031 "that ipa-sra replaces a pointer to an aggregate with.", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1032 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
|
1033 |
| 111 | 1034 DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE, |
| 1035 "tm-max-aggregate-size", | |
| 1036 "Size in bytes after which thread-local aggregates should be " | |
| 1037 "instrumented with the logging functions instead of save/restore " | |
| 1038 "pairs.", | |
| 1039 9, 0, 0) | |
| 1040 | |
| 1041 DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SPEED, | |
| 1042 "sra-max-scalarization-size-Ospeed", | |
| 1043 "Maximum size, in storage units, of an aggregate which should be " | |
| 1044 "considered for scalarization when compiling for speed.", | |
| 1045 0, 0, 0) | |
| 1046 | |
| 1047 DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SIZE, | |
| 1048 "sra-max-scalarization-size-Osize", | |
| 1049 "Maximum size, in storage units, of an aggregate which should be " | |
| 1050 "considered for scalarization when compiling for size.", | |
| 1051 0, 0, 0) | |
| 1052 | |
| 1053 DEFPARAM (PARAM_IPA_CP_VALUE_LIST_SIZE, | |
| 1054 "ipa-cp-value-list-size", | |
| 1055 "Maximum size of a list of values associated with each parameter for " | |
| 1056 "interprocedural constant propagation.", | |
|
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
|
1057 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
|
1058 |
| 111 | 1059 DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD, |
| 1060 "ipa-cp-eval-threshold", | |
| 1061 "Threshold ipa-cp opportunity evaluation that is still considered " | |
| 131 | 1062 "beneficial to clone.", |
| 111 | 1063 500, 0, 0) |
| 1064 | |
| 1065 DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY, | |
| 1066 "ipa-cp-recursion-penalty", | |
| 1067 "Percentage penalty the recursive functions will receive when they " | |
| 131 | 1068 "are evaluated for cloning.", |
| 111 | 1069 40, 0, 100) |
| 1070 | |
| 1071 DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY, | |
| 1072 "ipa-cp-single-call-penalty", | |
| 1073 "Percentage penalty functions containing a single call to another " | |
| 131 | 1074 "function will receive when they are evaluated for cloning.", |
| 111 | 1075 15, 0, 100) |
| 1076 | |
| 1077 DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS, | |
| 1078 "ipa-max-agg-items", | |
| 1079 "Maximum number of aggregate content items for a parameter in " | |
| 1080 "jump functions and lattices.", | |
| 1081 16, 0, 0) | |
| 1082 | |
| 1083 DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS, | |
| 1084 "ipa-cp-loop-hint-bonus", | |
| 1085 "Compile-time bonus IPA-CP assigns to candidates which make loop " | |
| 131 | 1086 "bounds or strides known.", |
| 111 | 1087 64, 0, 0) |
| 1088 | |
| 1089 DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS, | |
| 1090 "ipa-cp-array-index-hint-bonus", | |
| 1091 "Compile-time bonus IPA-CP assigns to candidates which make an array " | |
| 131 | 1092 "index known.", |
| 111 | 1093 48, 0, 0) |
| 1094 | |
| 1095 DEFPARAM (PARAM_IPA_MAX_AA_STEPS, | |
| 1096 "ipa-max-aa-steps", | |
| 1097 "Maximum number of statements that will be visited by IPA formal " | |
| 1098 "parameter analysis based on alias analysis in any given function.", | |
| 1099 25000, 0, 0) | |
| 1100 | |
|
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
|
1101 /* 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
|
1102 |
|
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
|
1103 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
|
1104 "lto-partitions", |
| 111 | 1105 "Number of partitions the program should be split to.", |
| 1106 32, 1, 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
|
1107 |
|
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
|
1108 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
|
1109 "lto-min-partition", |
| 111 | 1110 "Minimal size of a partition for LTO (in estimated instructions).", |
| 1111 10000, 0, 0) | |
| 1112 | |
| 1113 DEFPARAM (MAX_PARTITION_SIZE, | |
| 1114 "lto-max-partition", | |
| 1115 "Maximal size of a partition for LTO (in estimated instructions).", | |
| 1116 1000000, 0, INT_MAX) | |
|
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
|
1117 |
|
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
|
1118 /* 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
|
1119 |
|
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
|
1120 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
|
1121 "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
|
1122 "Maximum number of namespaces to search for alternatives when " |
| 111 | 1123 "name lookup fails.", |
|
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
|
1124 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
|
1125 |
| 111 | 1126 /* Maximum number of conditional store pairs that can be sunk. */ |
| 1127 DEFPARAM (PARAM_MAX_STORES_TO_SINK, | |
| 1128 "max-stores-to-sink", | |
| 1129 "Maximum number of conditional store pairs that can be sunk.", | |
| 1130 2, 0, 0) | |
| 1131 | |
| 1132 /* Override CASE_VALUES_THRESHOLD of when to switch from doing switch | |
| 1133 statements via if statements to using a table jump operation. If the value | |
| 1134 is 0, the default CASE_VALUES_THRESHOLD will be used. */ | |
| 1135 DEFPARAM (PARAM_CASE_VALUES_THRESHOLD, | |
| 1136 "case-values-threshold", | |
| 1137 "The smallest number of different values for which it is best to " | |
| 1138 "use a jump-table instead of a tree of conditional branches, " | |
| 1139 "if 0, use the default for the machine.", | |
| 1140 0, 0, 0) | |
| 1141 | |
| 1142 /* Data race flags for C++0x memory model compliance. */ | |
| 1143 DEFPARAM (PARAM_ALLOW_STORE_DATA_RACES, | |
| 1144 "allow-store-data-races", | |
| 1145 "Allow new data races on stores to be introduced.", | |
| 1146 0, 0, 1) | |
| 1147 | |
| 1148 /* Reassociation width to be used by tree reassoc optimization. */ | |
| 1149 DEFPARAM (PARAM_TREE_REASSOC_WIDTH, | |
| 1150 "tree-reassoc-width", | |
| 1151 "Set the maximum number of instructions executed in parallel in " | |
| 131 | 1152 "reassociated tree. If 0, use the target dependent heuristic.", |
| 111 | 1153 0, 0, 0) |
| 1154 | |
| 1155 DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS, | |
| 1156 "max-tail-merge-comparisons", | |
| 1157 "Maximum amount of similar bbs to compare a bb with.", | |
| 1158 10, 0, 0) | |
| 1159 | |
| 1160 DEFPARAM (PARAM_STORE_MERGING_ALLOW_UNALIGNED, | |
| 1161 "store-merging-allow-unaligned", | |
| 1162 "Allow the store merging pass to introduce unaligned stores " | |
| 1163 "if it is legal to do so.", | |
| 1164 1, 0, 1) | |
| 1165 | |
| 1166 DEFPARAM (PARAM_MAX_STORES_TO_MERGE, | |
| 1167 "max-stores-to-merge", | |
| 1168 "Maximum number of constant stores to merge in the " | |
| 1169 "store merging pass.", | |
| 1170 64, 2, 0) | |
| 1171 | |
| 1172 DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS, | |
| 1173 "max-tail-merge-iterations", | |
| 1174 "Maximum amount of iterations of the pass over a function.", | |
| 1175 2, 0, 0) | |
| 1176 | |
| 1177 /* Maximum number of strings for which strlen optimization pass will | |
| 1178 track string lenths. */ | |
| 1179 DEFPARAM (PARAM_MAX_TRACKED_STRLENS, | |
| 1180 "max-tracked-strlens", | |
| 1181 "Maximum number of strings for which strlen optimization pass will " | |
| 1182 "track string lengths.", | |
| 1183 10000, 0, 0) | |
| 1184 | |
| 1185 /* Keep this in sync with the sched_pressure_algorithm enum. */ | |
| 1186 DEFPARAM (PARAM_SCHED_PRESSURE_ALGORITHM, | |
| 1187 "sched-pressure-algorithm", | |
| 1188 "Which -fsched-pressure algorithm to apply.", | |
| 1189 1, 1, 2) | |
| 1190 | |
| 1191 /* Maximum length of candidate scans in straight-line strength reduction. */ | |
| 1192 DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN, | |
| 1193 "max-slsr-cand-scan", | |
| 1194 "Maximum length of candidate scans for straight-line " | |
| 1195 "strength reduction.", | |
| 1196 50, 1, 999999) | |
| 1197 | |
| 131 | 1198 /* ASan stands for AddressSanitizer: https://github.com/google/sanitizers. */ |
| 1199 | |
| 111 | 1200 DEFPARAM (PARAM_ASAN_STACK, |
| 1201 "asan-stack", | |
| 1202 "Enable asan stack protection.", | |
| 1203 1, 0, 1) | |
| 1204 | |
| 1205 DEFPARAM (PARAM_ASAN_PROTECT_ALLOCAS, | |
| 1206 "asan-instrument-allocas", | |
| 1207 "Enable asan allocas/VLAs protection.", | |
| 1208 1, 0, 1) | |
| 1209 | |
| 1210 DEFPARAM (PARAM_ASAN_GLOBALS, | |
| 1211 "asan-globals", | |
| 1212 "Enable asan globals protection.", | |
| 1213 1, 0, 1) | |
| 1214 | |
| 1215 DEFPARAM (PARAM_ASAN_INSTRUMENT_WRITES, | |
| 1216 "asan-instrument-writes", | |
| 1217 "Enable asan store operations protection.", | |
| 1218 1, 0, 1) | |
| 1219 | |
| 1220 DEFPARAM (PARAM_ASAN_INSTRUMENT_READS, | |
| 1221 "asan-instrument-reads", | |
| 1222 "Enable asan load operations protection.", | |
| 1223 1, 0, 1) | |
| 1224 | |
| 1225 DEFPARAM (PARAM_ASAN_MEMINTRIN, | |
| 1226 "asan-memintrin", | |
| 1227 "Enable asan builtin functions protection.", | |
| 1228 1, 0, 1) | |
| 1229 | |
| 1230 DEFPARAM (PARAM_ASAN_USE_AFTER_RETURN, | |
| 1231 "asan-use-after-return", | |
| 1232 "Enable asan detection of use-after-return bugs.", | |
| 1233 1, 0, 1) | |
| 1234 | |
| 1235 DEFPARAM (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD, | |
| 1236 "asan-instrumentation-with-call-threshold", | |
| 1237 "Use callbacks instead of inline code if number of accesses " | |
| 1238 "in function becomes greater or equal to this number.", | |
| 1239 7000, 0, INT_MAX) | |
| 1240 | |
| 1241 DEFPARAM (PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD, | |
| 1242 "use-after-scope-direct-emission-threshold", | |
| 1243 "Use direct poisoning/unpoisoning instructions for variables " | |
| 1244 "smaller or equal to this number.", | |
| 1245 256, 0, INT_MAX) | |
| 1246 | |
| 1247 DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS, | |
| 1248 "uninit-control-dep-attempts", | |
| 1249 "Maximum number of nested calls to search for control dependencies " | |
| 1250 "during uninitialized variable analysis.", | |
| 1251 1000, 1, 0) | |
| 1252 | |
| 1253 DEFPARAM (PARAM_FSM_SCALE_PATH_STMTS, | |
| 1254 "fsm-scale-path-stmts", | |
| 1255 "Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks.", | |
| 1256 2, 1, 10) | |
| 1257 | |
| 1258 DEFPARAM (PARAM_FSM_MAXIMUM_PHI_ARGUMENTS, | |
| 1259 "fsm-maximum-phi-arguments", | |
| 1260 "Maximum number of arguments a PHI may have before the FSM threader will not try to thread through its block.", | |
| 1261 100, 1, 999999) | |
| 1262 | |
| 1263 DEFPARAM (PARAM_FSM_SCALE_PATH_BLOCKS, | |
| 1264 "fsm-scale-path-blocks", | |
| 1265 "Scale factor to apply to the number of blocks in a threading path when comparing to the number of (scaled) statements.", | |
| 1266 3, 1, 10) | |
| 1267 | |
| 1268 DEFPARAM (PARAM_MAX_FSM_THREAD_PATH_INSNS, | |
| 1269 "max-fsm-thread-path-insns", | |
| 1270 "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path.", | |
| 1271 100, 1, 999999) | |
| 1272 | |
| 1273 DEFPARAM (PARAM_MAX_FSM_THREAD_LENGTH, | |
| 1274 "max-fsm-thread-length", | |
| 1275 "Maximum number of basic blocks on a finite state automaton jump thread path.", | |
| 1276 10, 1, 999999) | |
| 1277 | |
| 1278 DEFPARAM (PARAM_MAX_FSM_THREAD_PATHS, | |
| 1279 "max-fsm-thread-paths", | |
| 1280 "Maximum number of new jump thread paths to create for a finite state automaton.", | |
| 1281 50, 1, 999999) | |
| 1282 | |
| 1283 DEFPARAM (PARAM_PARLOOPS_CHUNK_SIZE, | |
| 1284 "parloops-chunk-size", | |
| 1285 "Chunk size of omp schedule for loops parallelized by parloops.", | |
| 1286 0, 0, 0) | |
| 1287 | |
| 1288 DEFPARAMENUM5 (PARAM_PARLOOPS_SCHEDULE, | |
| 1289 "parloops-schedule", | |
| 1290 "Schedule type of omp schedule for loops parallelized by " | |
| 1291 "parloops (static, dynamic, guided, auto, runtime).", | |
| 1292 static, | |
| 1293 static, dynamic, guided, auto, runtime) | |
| 1294 | |
| 131 | 1295 DEFPARAM (PARAM_PARLOOPS_MIN_PER_THREAD, |
| 1296 "parloops-min-per-thread", | |
| 1297 "Minimum number of iterations per thread of an innermost " | |
| 1298 "parallelized loop.", | |
| 1299 100, 2, 0) | |
| 1300 | |
| 111 | 1301 DEFPARAM (PARAM_MAX_SSA_NAME_QUERY_DEPTH, |
| 1302 "max-ssa-name-query-depth", | |
| 1303 "Maximum recursion depth allowed when querying a property of an" | |
| 1304 " SSA name.", | |
| 1305 3, 1, 10) | |
| 1306 | |
| 1307 DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_INSNS, | |
| 1308 "max-rtl-if-conversion-insns", | |
| 1309 "Maximum number of insns in a basic block to consider for RTL " | |
| 1310 "if-conversion.", | |
| 1311 10, 0, 99) | |
| 1312 | |
| 1313 DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST, | |
| 1314 "max-rtl-if-conversion-predictable-cost", | |
| 1315 "Maximum permissible cost for the sequence that would be " | |
| 1316 "generated by the RTL if-conversion pass for a branch that " | |
| 1317 "is considered predictable.", | |
| 1318 20, 0, 200) | |
| 1319 | |
| 1320 DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST, | |
| 1321 "max-rtl-if-conversion-unpredictable-cost", | |
| 1322 "Maximum permissible cost for the sequence that would be " | |
| 1323 "generated by the RTL if-conversion pass for a branch that " | |
| 1324 "is considered unpredictable.", | |
| 1325 40, 0, 200) | |
| 1326 | |
| 1327 DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES, | |
| 1328 "hsa-gen-debug-stores", | |
| 131 | 1329 "Level of hsa debug stores verbosity.", |
| 111 | 1330 0, 0, 1) |
| 1331 | |
| 1332 DEFPARAM (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS, | |
| 1333 "max-speculative-devirt-maydefs", | |
| 1334 "Maximum number of may-defs visited when devirtualizing " | |
| 131 | 1335 "speculatively.", 50, 0, 0) |
| 111 | 1336 |
| 1337 DEFPARAM (PARAM_MAX_VRP_SWITCH_ASSERTIONS, | |
| 1338 "max-vrp-switch-assertions", | |
| 1339 "Maximum number of assertions to add along the default " | |
| 131 | 1340 "edge of a switch statement during VRP.", |
| 111 | 1341 10, 0, 0) |
| 1342 | |
| 1343 DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK, | |
| 1344 "vect-epilogues-nomask", | |
| 1345 "Enable loop epilogue vectorization using smaller vector size.", | |
| 1346 0, 0, 1) | |
| 1347 | |
| 131 | 1348 DEFPARAM(PARAM_UNROLL_JAM_MIN_PERCENT, |
| 1349 "unroll-jam-min-percent", | |
| 1350 "Minimum percentage of memrefs that must go away for unroll-and-jam to be considered profitable.", | |
| 1351 1, 0, 100) | |
| 1352 | |
| 1353 DEFPARAM(PARAM_UNROLL_JAM_MAX_UNROLL, | |
| 1354 "unroll-jam-max-unroll", | |
| 1355 "Maximum unroll factor for the unroll-and-jam transformation.", | |
| 1356 4, 0, 0) | |
| 1357 | |
| 1358 DEFPARAM(PARAM_AVOID_FMA_MAX_BITS, | |
| 1359 "avoid-fma-max-bits", | |
| 1360 "Maximum number of bits for which we avoid creating FMAs.", | |
| 1361 0, 0, 512) | |
| 1362 | |
| 0 | 1363 /* |
| 111 | 1364 |
| 0 | 1365 Local variables: |
| 1366 mode:c | |
| 1367 End: | |
| 1368 */ |