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