]>
Commit | Line | Data |
---|---|---|
c6d9a88c | 1 | /* params.def - Run-time parameters. |
cbe34bb5 | 2 | Copyright (C) 2001-2017 Free Software Foundation, Inc. |
c6d9a88c MM |
3 | Written by Mark Mitchell <mark@codesourcery.com>. |
4 | ||
1322177d | 5 | This file is part of GCC. |
c6d9a88c | 6 | |
1322177d LB |
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 | |
9dcd6f09 | 9 | Software Foundation; either version 3, or (at your option) any later |
1322177d | 10 | version. |
c6d9a88c | 11 | |
1322177d LB |
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. | |
c6d9a88c MM |
16 | |
17 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
c6d9a88c MM |
20 | |
21 | /* This file contains definitions for language-independent | |
1eb68dca | 22 | parameters. The DEFPARAM macro takes 6 arguments: |
c6d9a88c | 23 | |
0443f602 | 24 | - The enumeral corresponding to this parameter. |
c6d9a88c | 25 | |
b8698a0f | 26 | - The name that can be used to set this parameter using the |
c6d9a88c MM |
27 | command-line option `--param <name>=<value>'. |
28 | ||
29 | - A help string explaining how the parameter is used. | |
30 | ||
1c4c47db JO |
31 | - A default value for the parameter. |
32 | ||
9e7705cb | 33 | - The minimum acceptable value for the parameter. |
1eb68dca | 34 | |
9e7705cb | 35 | - The maximum acceptable value for the parameter (if greater than |
1eb68dca KZ |
36 | the minimum). |
37 | ||
1f600fea TV |
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 | ||
1c4c47db | 43 | Be sure to add an entry to invoke.texi summarizing the parameter. */ |
c6d9a88c | 44 | |
3a4fd356 JH |
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", | |
a7b2e184 | 49 | "Maximal estimated outcome of branch considered predictable.", |
3a4fd356 JH |
50 | 2, 0, 50) |
51 | ||
42f7b0fa JH |
52 | DEFPARAM (PARAM_INLINE_MIN_SPEEDUP, |
53 | "inline-min-speedup", | |
bd2c6270 | 54 | "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.", |
540b7af0 | 55 | 8, 0, 0) |
42f7b0fa | 56 | |
a6227154 KG |
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. | |
e5c4f28a | 61 | The default value is 450. |
a6227154 | 62 | Only functions marked inline (or methods defined in the class |
e5c4f28a | 63 | definition for C++) are affected by this. |
a6227154 KG |
64 | There are more restrictions to inlining: If inlined functions |
65 | call other functions, the already inlined instructions are | |
b8698a0f | 66 | counted and once the recursive inline limit (see |
a6227154 KG |
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", | |
a7b2e184 | 71 | "The maximum number of instructions in a single function eligible for inlining.", |
172d54e0 | 72 | 400, 0, 0) |
a6227154 | 73 | |
bc522472 KG |
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. | |
7802ca7c | 80 | The default value is 40. */ |
bc522472 KG |
81 | DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, |
82 | "max-inline-insns-auto", | |
a7b2e184 | 83 | "The maximum number of instructions when automatically inlining.", |
7802ca7c | 84 | 40, 0, 0) |
bc522472 | 85 | |
6de9cd9a DN |
86 | DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, |
87 | "max-inline-insns-recursive", | |
a7b2e184 | 88 | "The maximum number of instructions inline function can grow to via recursive inlining.", |
172d54e0 | 89 | 450, 0, 0) |
6de9cd9a DN |
90 | |
91 | DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO, | |
92 | "max-inline-insns-recursive-auto", | |
a7b2e184 | 93 | "The maximum number of instructions non-inline function can grow to via recursive inlining.", |
172d54e0 | 94 | 450, 0, 0) |
6de9cd9a DN |
95 | |
96 | DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH, | |
97 | "max-inline-recursive-depth", | |
a7b2e184 | 98 | "The maximum depth of recursive inlining for inline functions.", |
e06c0feb | 99 | 8, 0, 0) |
6de9cd9a DN |
100 | |
101 | DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO, | |
102 | "max-inline-recursive-depth-auto", | |
a7b2e184 | 103 | "The maximum depth of recursive inlining for non-inline functions.", |
e06c0feb | 104 | 8, 0, 0) |
6de9cd9a | 105 | |
c5a4444c JH |
106 | DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY, |
107 | "min-inline-recursive-probability", | |
a7b2e184 | 108 | "Inline recursively only when the probability of call being executed exceeds the parameter.", |
c5a4444c JH |
109 | 10, 0, 0) |
110 | ||
796bda22 JH |
111 | /* Limit of iterations of early inliner. This basically bounds number of |
112 | nested indirect calls early inliner can resolve. Deeper chains are still | |
113 | handled by late inlining. */ | |
114 | DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS, | |
115 | "max-early-inliner-iterations", | |
a7b2e184 | 116 | "The maximum number of nested indirect inlining performed by early inliner.", |
ec4224ac | 117 | 1, 0, 0) |
796bda22 | 118 | |
c5d0600d JH |
119 | /* Limit on probability of entry BB. */ |
120 | DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY, | |
121 | "comdat-sharing-probability", | |
a7b2e184 | 122 | "Probability that COMDAT function will be shared with different compilation unit.", |
c5d0600d JH |
123 | 20, 0, 0) |
124 | ||
3e485f62 JH |
125 | /* Limit on probability of entry BB. */ |
126 | DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY, | |
127 | "partial-inlining-entry-probability", | |
a7b2e184 | 128 | "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen.", |
e929e611 | 129 | 70, 0, 100) |
3e485f62 | 130 | |
f37a4f14 RE |
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", | |
a7b2e184 | 135 | "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling.", |
e06c0feb | 136 | 1, 0, 0) |
b8698a0f | 137 | |
acdc40df DN |
138 | /* Limit loop autovectorization to loops with large enough iteration count. */ |
139 | DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, | |
140 | "min-vect-loop-bound", | |
a7b2e184 | 141 | "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.", |
8d888559 | 142 | 1, 1, 0) |
acdc40df | 143 | |
0443f602 JO |
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", | |
a7b2e184 | 152 | "The maximum number of instructions to consider to fill a delay slot.", |
e06c0feb | 153 | 100, 0, 0) |
0443f602 | 154 | |
d5d063d7 JO |
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", | |
a7b2e184 | 163 | "The maximum number of instructions to consider to find accurate live register information.", |
e06c0feb | 164 | 333, 0, 0) |
d5d063d7 | 165 | |
b8698a0f | 166 | /* This parameter limits the number of branch elements that the |
ff7cc307 | 167 | scheduler will track anti-dependencies through without resetting |
b8698a0f L |
168 | the tracking mechanism. Large functions with few calls or barriers |
169 | can generate lists containing many 1000's of dependencies. Generally | |
4a121cc3 AM |
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", | |
a7b2e184 | 173 | "The maximum length of scheduling's pending operations list.", |
e06c0feb | 174 | 32, 0, 0) |
4a121cc3 | 175 | |
06d7e8e7 BS |
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", | |
a7b2e184 | 180 | "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop.", |
06d7e8e7 BS |
181 | 40, 0, 0) |
182 | ||
b58b1157 JH |
183 | DEFPARAM(PARAM_LARGE_FUNCTION_INSNS, |
184 | "large-function-insns", | |
a7b2e184 | 185 | "The size of function body to be considered large.", |
e5c4f28a | 186 | 2700, 0, 0) |
b58b1157 JH |
187 | DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH, |
188 | "large-function-growth", | |
a7b2e184 | 189 | "Maximal growth due to inlining of large function (in percent).", |
e06c0feb | 190 | 100, 0, 0) |
b4f32d07 JH |
191 | DEFPARAM(PARAM_LARGE_UNIT_INSNS, |
192 | "large-unit-insns", | |
a7b2e184 | 193 | "The size of translation unit to be considered large.", |
b4f32d07 | 194 | 10000, 0, 0) |
b58b1157 JH |
195 | DEFPARAM(PARAM_INLINE_UNIT_GROWTH, |
196 | "inline-unit-growth", | |
a7b2e184 | 197 | "How much can given compilation unit grow because of the inlining (in percent).", |
9a820e84 | 198 | 20, 0, 0) |
5e45130d JH |
199 | DEFPARAM(PARAM_IPCP_UNIT_GROWTH, |
200 | "ipcp-unit-growth", | |
a7b2e184 | 201 | "How much can given compilation unit grow because of the interprocedural constant propagation (in percent).", |
5e45130d | 202 | 10, 0, 0) |
85057983 JH |
203 | DEFPARAM(PARAM_EARLY_INLINING_INSNS, |
204 | "early-inlining-insns", | |
a7b2e184 | 205 | "Maximal estimated growth of function body caused by early inlining of single call.", |
3620b606 | 206 | 14, 0, 0) |
ff28a94d JH |
207 | DEFPARAM(PARAM_LARGE_STACK_FRAME, |
208 | "large-stack-frame", | |
a7b2e184 | 209 | "The size of stack frame to be considered large.", |
ff28a94d JH |
210 | 256, 0, 0) |
211 | DEFPARAM(PARAM_STACK_FRAME_GROWTH, | |
212 | "large-stack-frame-growth", | |
a7b2e184 | 213 | "Maximal stack frame growth due to inlining (in percent).", |
ff28a94d | 214 | 1000, 0, 0) |
b58b1157 | 215 | |
ee8f15c6 JL |
216 | DEFPARAM(PARAM_STACK_CLASH_PROTECTION_GUARD_SIZE, |
217 | "stack-clash-protection-guard-size", | |
218 | "Size of the stack guard expressed as a power of two.", | |
219 | 12, 12, 30) | |
220 | ||
221 | DEFPARAM(PARAM_STACK_CLASH_PROTECTION_PROBE_INTERVAL, | |
222 | "stack-clash-protection-probe-interval", | |
223 | "Interval in which to probe the stack expressed as a power of two.", | |
224 | 12, 10, 16) | |
225 | ||
f1fa37ff MM |
226 | /* The GCSE optimization will be disabled if it would require |
227 | significantly more memory than this value. */ | |
228 | DEFPARAM(PARAM_MAX_GCSE_MEMORY, | |
229 | "max-gcse-memory", | |
a7b2e184 | 230 | "The maximum amount of memory to be allocated by GCSE.", |
87d8dd6c | 231 | 128 * 1024 * 1024, 0, 0) |
3906a4a1 | 232 | |
29fa95ed JL |
233 | /* The GCSE optimization of an expression will avoided if the ratio of |
234 | insertions to deletions is greater than this value. */ | |
235 | DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO, | |
236 | "max-gcse-insertion-ratio", | |
a7b2e184 | 237 | "The maximum ratio of insertions to deletions of expressions in GCSE.", |
29fa95ed JL |
238 | 20, 0, 0) |
239 | ||
f9957958 MH |
240 | /* This is the threshold ratio when to perform partial redundancy |
241 | elimination after reload. We perform partial redundancy elimination | |
242 | when the following holds: | |
243 | (Redundant load execution count) | |
244 | ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION | |
245 | (Added loads execution count) */ | |
246 | DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION, | |
247 | "gcse-after-reload-partial-fraction", | |
a7b2e184 | 248 | "The threshold ratio for performing partial redundancy elimination after reload.", |
e06c0feb | 249 | 3, 0, 0) |
f9957958 MH |
250 | /* This is the threshold ratio of the critical edges execution count compared to |
251 | the redundant loads execution count that permits performing the load | |
252 | redundancy elimination in gcse after reload. */ | |
253 | DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION, | |
254 | "gcse-after-reload-critical-fraction", | |
a7b2e184 | 255 | "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload.", |
e06c0feb | 256 | 10, 0, 0) |
20160347 MK |
257 | |
258 | /* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor | |
259 | to calculate maximum distance for which an expression is allowed to move | |
260 | from its rtx_cost. */ | |
261 | DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO, | |
262 | "gcse-cost-distance-ratio", | |
a7b2e184 | 263 | "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations.", |
20160347 MK |
264 | 10, 0, 0) |
265 | /* GCSE won't restrict distance for which an expression with rtx_cost greater | |
266 | than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */ | |
267 | DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST, | |
268 | "gcse-unrestricted-cost", | |
a7b2e184 | 269 | "Cost at which GCSE optimizations will not constraint the distance an expression can travel.", |
20160347 MK |
270 | 3, 0, 0) |
271 | ||
cad9aa15 MK |
272 | /* How deep from a given basic block the dominator tree should be searched |
273 | for expressions to hoist to the block. The value of 0 will avoid limiting | |
274 | the search. */ | |
275 | DEFPARAM(PARAM_MAX_HOIST_DEPTH, | |
276 | "max-hoist-depth", | |
a7b2e184 | 277 | "Maximum depth of search in the dominator tree for expressions to hoist.", |
cad9aa15 MK |
278 | 30, 0, 0) |
279 | ||
b7dce216 KT |
280 | |
281 | /* When synthesizing expnonentiation by a real constant operations using square | |
282 | roots, this controls how deep sqrt chains we are willing to generate. */ | |
283 | DEFPARAM(PARAM_MAX_POW_SQRT_DEPTH, | |
284 | "max-pow-sqrt-depth", | |
a7b2e184 | 285 | "Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant.", |
b7dce216 KT |
286 | 5, 1, 32) |
287 | ||
03e9dbc9 | 288 | /* This parameter limits the number of insns in a loop that will be unrolled, |
701ad47e | 289 | and by how much the loop is unrolled. |
b8698a0f | 290 | |
701ad47e JH |
291 | This limit should be at most half of the peeling limits: loop unroller |
292 | decides to not unroll loops that iterate fewer than 2*number of allowed | |
a1105617 | 293 | unrollings and thus we would have loops that are neither peeled or unrolled |
701ad47e | 294 | otherwise. */ |
03e9dbc9 MM |
295 | DEFPARAM(PARAM_MAX_UNROLLED_INSNS, |
296 | "max-unrolled-insns", | |
a7b2e184 | 297 | "The maximum number of instructions to consider to unroll in a loop.", |
e06c0feb | 298 | 200, 0, 0) |
b17d5d7c ZD |
299 | /* This parameter limits how many times the loop is unrolled depending |
300 | on number of insns really executed in each iteration. */ | |
301 | DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS, | |
302 | "max-average-unrolled-insns", | |
a7b2e184 | 303 | "The maximum number of instructions to consider to unroll in a loop on average.", |
e06c0feb | 304 | 80, 0, 0) |
b17d5d7c ZD |
305 | /* The maximum number of unrollings of a single loop. */ |
306 | DEFPARAM(PARAM_MAX_UNROLL_TIMES, | |
307 | "max-unroll-times", | |
a7b2e184 | 308 | "The maximum number of unrollings of a single loop.", |
e06c0feb | 309 | 8, 0, 0) |
b17d5d7c ZD |
310 | /* The maximum number of insns of a peeled loop. */ |
311 | DEFPARAM(PARAM_MAX_PEELED_INSNS, | |
312 | "max-peeled-insns", | |
a7b2e184 | 313 | "The maximum number of insns of a peeled loop.", |
b3d0cc60 | 314 | 100, 0, 0) |
b17d5d7c ZD |
315 | /* The maximum number of peelings of a single loop. */ |
316 | DEFPARAM(PARAM_MAX_PEEL_TIMES, | |
317 | "max-peel-times", | |
a7b2e184 | 318 | "The maximum number of peelings of a single loop.", |
e06c0feb | 319 | 16, 0, 0) |
519cac4a JH |
320 | /* The maximum number of peelings of a single loop that is peeled completely. */ |
321 | DEFPARAM(PARAM_MAX_PEEL_BRANCHES, | |
322 | "max-peel-branches", | |
a7b2e184 | 323 | "The maximum number of branches on the path through the peeled sequence.", |
519cac4a | 324 | 32, 0, 0) |
b17d5d7c ZD |
325 | /* The maximum number of insns of a peeled loop. */ |
326 | DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS, | |
327 | "max-completely-peeled-insns", | |
a7b2e184 | 328 | "The maximum number of insns of a completely peeled loop.", |
c1b4f9c6 | 329 | 200, 0, 0) |
b17d5d7c ZD |
330 | /* The maximum number of peelings of a single loop that is peeled completely. */ |
331 | DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES, | |
332 | "max-completely-peel-times", | |
a7b2e184 | 333 | "The maximum number of peelings of a single loop that is peeled completely.", |
e06c0feb | 334 | 16, 0, 0) |
b17d5d7c ZD |
335 | /* The maximum number of insns of a peeled loop that rolls only once. */ |
336 | DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS, | |
337 | "max-once-peeled-insns", | |
a7b2e184 | 338 | "The maximum number of insns of a peeled loop that rolls only once.", |
e06c0feb | 339 | 400, 0, 0) |
30bc1dca RG |
340 | /* The maximum depth of a loop nest we completely peel. */ |
341 | DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS, | |
342 | "max-completely-peel-loop-nest-depth", | |
a7b2e184 | 343 | "The maximum depth of a loop nest we completely peel.", |
30bc1dca | 344 | 8, 0, 0) |
194734e9 | 345 | |
617b465c ZD |
346 | /* The maximum number of insns of an unswitched loop. */ |
347 | DEFPARAM(PARAM_MAX_UNSWITCH_INSNS, | |
348 | "max-unswitch-insns", | |
a7b2e184 | 349 | "The maximum number of insns of an unswitched loop.", |
e06c0feb | 350 | 50, 0, 0) |
617b465c ZD |
351 | /* The maximum level of recursion in unswitch_single_loop. */ |
352 | DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, | |
353 | "max-unswitch-level", | |
a7b2e184 | 354 | "The maximum number of unswitchings in a single loop.", |
e06c0feb | 355 | 3, 0, 0) |
617b465c | 356 | |
568876dc JH |
357 | /* The maximum number of insns in loop header duplicated by he copy loop |
358 | headers pass. */ | |
359 | DEFPARAM(PARAM_MAX_LOOP_HEADER_INSNS, | |
360 | "max-loop-header-insns", | |
361 | "The maximum number of insns in loop header duplicated by he copy loop headers pass.", | |
362 | 20, 0, 0) | |
363 | ||
e9eb809d ZD |
364 | /* The maximum number of iterations of a loop the brute force algorithm |
365 | for analysis of # of iterations of the loop tries to evaluate. */ | |
366 | DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, | |
367 | "max-iterations-to-track", | |
a7b2e184 | 368 | "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates.", |
e06c0feb | 369 | 1000, 0, 0) |
45b9a14b BS |
370 | /* A cutoff to avoid costly computations of the number of iterations in |
371 | the doloop transformation. */ | |
372 | DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST, | |
373 | "max-iterations-computation-cost", | |
a7b2e184 | 374 | "Bound on the cost of an expression to compute the number of iterations.", |
45b9a14b | 375 | 10, 0, 0) |
e9eb809d | 376 | |
e5626198 AZ |
377 | /* This parameter is used to tune SMS MAX II calculations. */ |
378 | DEFPARAM(PARAM_SMS_MAX_II_FACTOR, | |
379 | "sms-max-ii-factor", | |
a7b2e184 | 380 | "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop.", |
e06c0feb | 381 | 100, 0, 0) |
3e2fdd24 RE |
382 | /* The minimum value of stage count that swing modulo scheduler will generate. */ |
383 | DEFPARAM(PARAM_SMS_MIN_SC, | |
384 | "sms-min-sc", | |
385 | "The minimum value of stage count that swing modulo scheduler will generate.", | |
386 | 2, 1, 1) | |
e5626198 AZ |
387 | DEFPARAM(PARAM_SMS_DFA_HISTORY, |
388 | "sms-dfa-history", | |
a7b2e184 | 389 | "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA.", |
e06c0feb | 390 | 0, 0, 0) |
e5626198 AZ |
391 | DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, |
392 | "sms-loop-average-count-threshold", | |
a7b2e184 | 393 | "A threshold on the average loop count considered by the swing modulo scheduler.", |
e06c0feb | 394 | 0, 0, 0) |
e5626198 | 395 | |
b131b583 TJ |
396 | DEFPARAM(HOT_BB_COUNT_WS_PERMILLE, |
397 | "hot-bb-count-ws-permille", | |
398 | "A basic block profile count is considered hot if it contributes to " | |
a7b2e184 | 399 | "the given permillage of the entire profiled execution.", |
b131b583 | 400 | 999, 0, 1000) |
194734e9 JH |
401 | DEFPARAM(HOT_BB_FREQUENCY_FRACTION, |
402 | "hot-bb-frequency-fraction", | |
a7b2e184 | 403 | "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.", |
e06c0feb | 404 | 1000, 0, 0) |
95b9a3a5 | 405 | |
bfaa17c1 TJ |
406 | DEFPARAM(UNLIKELY_BB_COUNT_FRACTION, |
407 | "unlikely-bb-count-fraction", | |
a7b2e184 | 408 | "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely.", |
bfaa17c1 TJ |
409 | 20, 1, 10000) |
410 | ||
edbed3d3 JH |
411 | DEFPARAM (PARAM_ALIGN_THRESHOLD, |
412 | "align-threshold", | |
a7b2e184 | 413 | "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.", |
7b55f98f | 414 | 100, 1, 0) |
edbed3d3 JH |
415 | |
416 | DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, | |
417 | "align-loop-iterations", | |
ff7b374b | 418 | "Loops iterating at least selected number of iterations will get loop alignment..", |
edbed3d3 JH |
419 | 4, 0, 0) |
420 | ||
95b9a3a5 JH |
421 | /* For guessed profiles, the loops having unknown number of iterations |
422 | are predicted to iterate relatively few (10) times at average. | |
423 | For functions containing one loop with large known number of iterations | |
424 | and other loops having unbounded loops we would end up predicting all | |
c83eecad | 425 | the other loops cold that is not usually the case. So we need to artificially |
b8698a0f | 426 | flatten the profile. |
95b9a3a5 | 427 | |
6416ae7f | 428 | We need to cut the maximal predicted iterations to large enough iterations |
b131b583 | 429 | so the loop appears important, but safely within maximum hotness |
95b9a3a5 JH |
430 | range. */ |
431 | ||
432 | DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS, | |
433 | "max-predicted-iterations", | |
a7b2e184 | 434 | "The maximum number of loop iterations we predict statically.", |
95b9a3a5 | 435 | 100, 0, 0) |
942df739 RX |
436 | |
437 | /* This parameter controls the probability of builtin_expect. The default | |
438 | value is 90%. This empirical value is obtained through the weighted | |
439 | probability of FDO counters (with the FDO count value as the weight) | |
a7b2e184 | 440 | in some real world programs: |
942df739 RX |
441 | (1) Google performance test benchmarks: the probability is 0.9081. |
442 | (2) Linux 3.3 kernel running Google search workload: the probability | |
443 | is 0.8717. */ | |
444 | ||
445 | DEFPARAM(BUILTIN_EXPECT_PROBABILITY, | |
446 | "builtin-expect-probability", | |
447 | "Set the estimated probability in percentage for builtin expect. The default value is 90% probability.", | |
448 | 90, 0, 100) | |
5c856b23 JH |
449 | DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, |
450 | "tracer-dynamic-coverage-feedback", | |
a7b2e184 | 451 | "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.", |
e06c0feb | 452 | 95, 0, 100) |
5c856b23 JH |
453 | DEFPARAM(TRACER_DYNAMIC_COVERAGE, |
454 | "tracer-dynamic-coverage", | |
a7b2e184 | 455 | "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available.", |
e06c0feb | 456 | 75, 0, 100) |
5c856b23 JH |
457 | DEFPARAM(TRACER_MAX_CODE_GROWTH, |
458 | "tracer-max-code-growth", | |
a7b2e184 | 459 | "Maximal code growth caused by tail duplication (in percent).", |
e06c0feb | 460 | 100, 0, 0) |
5c856b23 JH |
461 | DEFPARAM(TRACER_MIN_BRANCH_RATIO, |
462 | "tracer-min-branch-ratio", | |
a7b2e184 | 463 | "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent).", |
e06c0feb | 464 | 10, 0, 100) |
5c856b23 JH |
465 | DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK, |
466 | "tracer-min-branch-probability-feedback", | |
a7b2e184 | 467 | "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available.", |
e06c0feb | 468 | 80, 0, 100) |
5c856b23 JH |
469 | DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, |
470 | "tracer-min-branch-probability", | |
a7b2e184 | 471 | "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available.", |
e06c0feb | 472 | 50, 0, 100) |
3788cc17 | 473 | |
5f24e0dc RH |
474 | /* The maximum number of incoming edges to consider for crossjumping. */ |
475 | DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES, | |
476 | "max-crossjump-edges", | |
a7b2e184 | 477 | "The maximum number of incoming edges to consider for crossjumping.", |
e06c0feb | 478 | 100, 0, 0) |
5f24e0dc | 479 | |
12183e0f PH |
480 | /* The minimum number of matching instructions to consider for crossjumping. */ |
481 | DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS, | |
482 | "min-crossjump-insns", | |
a7b2e184 | 483 | "The minimum number of matching instructions to consider for crossjumping.", |
781b2e62 | 484 | 5, 1, 0) |
12183e0f | 485 | |
f935b9e0 DE |
486 | /* The maximum number expansion factor when copying basic blocks. */ |
487 | DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS, | |
488 | "max-grow-copy-bb-insns", | |
a7b2e184 | 489 | "The maximum expansion factor when copying basic blocks.", |
f935b9e0 DE |
490 | 8, 0, 0) |
491 | ||
bbcb0c05 SB |
492 | /* The maximum number of insns to duplicate when unfactoring computed gotos. */ |
493 | DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS, | |
494 | "max-goto-duplication-insns", | |
a7b2e184 | 495 | "The maximum number of insns to duplicate when unfactoring computed gotos.", |
bbcb0c05 SB |
496 | 8, 0, 0) |
497 | ||
9bf8cfbf ZD |
498 | /* The maximum length of path considered in cse. */ |
499 | DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH, | |
500 | "max-cse-path-length", | |
a7b2e184 | 501 | "The maximum length of path considered in cse.", |
75ef8e3d | 502 | 10, 1, 0) |
95b9a3a5 | 503 | DEFPARAM(PARAM_MAX_CSE_INSNS, |
921b02cd | 504 | "max-cse-insns", |
a7b2e184 | 505 | "The maximum instructions CSE process before flushing.", |
95b9a3a5 | 506 | 1000, 0, 0) |
9bf8cfbf | 507 | |
a7e5372d ZD |
508 | /* The cost of expression in loop invariant motion that is considered |
509 | expensive. */ | |
510 | DEFPARAM(PARAM_LIM_EXPENSIVE, | |
511 | "lim-expensive", | |
a7b2e184 | 512 | "The minimum cost of an expensive expression in the loop invariant motion.", |
e06c0feb | 513 | 20, 0, 0) |
a7e5372d | 514 | |
8b11a64c ZD |
515 | /* Bound on number of candidates for induction variables below that |
516 | all candidates are considered for each use in induction variable | |
517 | optimizations. */ | |
518 | ||
519 | DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, | |
520 | "iv-consider-all-candidates-bound", | |
a7b2e184 | 521 | "Bound on number of candidates below that all candidates are considered in iv optimizations.", |
9bf63f8c | 522 | 40, 0, 0) |
8b11a64c ZD |
523 | |
524 | /* The induction variable optimizations give up on loops that contain more | |
525 | induction variable uses. */ | |
526 | ||
527 | DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES, | |
528 | "iv-max-considered-uses", | |
a7b2e184 | 529 | "Bound on number of iv uses in loop optimized in iv optimizations.", |
e06c0feb | 530 | 250, 0, 0) |
8b11a64c | 531 | |
36f5ada1 ZD |
532 | /* If there are at most this number of ivs in the set, try removing unnecessary |
533 | ivs from the set always. */ | |
534 | ||
535 | DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, | |
536 | "iv-always-prune-cand-set-bound", | |
a7b2e184 | 537 | "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization.", |
36f5ada1 ZD |
538 | 10, 0, 0) |
539 | ||
4661839e ML |
540 | DEFPARAM(PARAM_AVG_LOOP_NITER, |
541 | "avg-loop-niter", | |
542 | "Average number of iterations of a loop.", | |
543 | 10, 1, 0) | |
544 | ||
d155c6fe JL |
545 | DEFPARAM(PARAM_DSE_MAX_OBJECT_SIZE, |
546 | "dse-max-object-size", | |
547 | "Maximum size (in bytes) of objects tracked bytewise by dead store elimination.", | |
548 | 256, 0, 0) | |
549 | ||
2412d35c SP |
550 | DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, |
551 | "scev-max-expr-size", | |
a7b2e184 | 552 | "Bound on size of expressions used in the scalar evolutions analyzer.", |
14dd9aab SP |
553 | 100, 0, 0) |
554 | ||
555 | DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY, | |
556 | "scev-max-expr-complexity", | |
a7b2e184 | 557 | "Bound on the complexity of the expressions in the scalar evolutions analyzer.", |
14dd9aab | 558 | 10, 0, 0) |
2412d35c | 559 | |
1cfcd39e BC |
560 | DEFPARAM (PARAM_MAX_TREE_IF_CONVERSION_PHI_ARGS, |
561 | "max-tree-if-conversion-phi-args", | |
562 | "Maximum number of arguments in a PHI supported by TREE if-conversion " | |
563 | "unless the loop is marked with simd pragma.", | |
564 | 4, 2, 0) | |
565 | ||
bc1edb77 VK |
566 | DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS, |
567 | "vect-max-version-for-alignment-checks", | |
a7b2e184 | 568 | "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check.", |
c12cc930 KB |
569 | 6, 0, 0) |
570 | ||
bc1edb77 VK |
571 | DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, |
572 | "vect-max-version-for-alias-checks", | |
a7b2e184 | 573 | "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check.", |
bc1edb77 VK |
574 | 10, 0, 0) |
575 | ||
4f17aa0b XDL |
576 | DEFPARAM(PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT, |
577 | "vect-max-peeling-for-alignment", | |
91cd87db | 578 | "Maximum number of loop peels to enhance alignment of data references in a loop.", |
4f17aa0b XDL |
579 | -1, -1, 64) |
580 | ||
c65ecebc JH |
581 | DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS, |
582 | "max-cselib-memory-locations", | |
a7b2e184 | 583 | "The maximum memory locations recorded by cselib.", |
e06c0feb | 584 | 500, 0, 0) |
c65ecebc | 585 | |
3788cc17 ZW |
586 | #ifdef ENABLE_GC_ALWAYS_COLLECT |
587 | # define GGC_MIN_EXPAND_DEFAULT 0 | |
737c38d1 | 588 | # define GGC_MIN_HEAPSIZE_DEFAULT 0 |
3788cc17 ZW |
589 | #else |
590 | # define GGC_MIN_EXPAND_DEFAULT 30 | |
737c38d1 | 591 | # define GGC_MIN_HEAPSIZE_DEFAULT 4096 |
3788cc17 ZW |
592 | #endif |
593 | ||
594 | DEFPARAM(GGC_MIN_EXPAND, | |
595 | "ggc-min-expand", | |
a7b2e184 | 596 | "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap.", |
e06c0feb | 597 | GGC_MIN_EXPAND_DEFAULT, 0, 0) |
3788cc17 | 598 | |
3788cc17 ZW |
599 | DEFPARAM(GGC_MIN_HEAPSIZE, |
600 | "ggc-min-heapsize", | |
a7b2e184 | 601 | "Minimum heap size before we start collecting garbage, in kilobytes.", |
e06c0feb | 602 | GGC_MIN_HEAPSIZE_DEFAULT, 0, 0) |
737c38d1 GK |
603 | |
604 | #undef GGC_MIN_EXPAND_DEFAULT | |
605 | #undef GGC_MIN_HEAPSIZE_DEFAULT | |
3788cc17 | 606 | |
0bcf8261 JH |
607 | DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS, |
608 | "max-reload-search-insns", | |
a7b2e184 | 609 | "The maximum number of instructions to search backward when looking for equivalent reload.", |
e06c0feb | 610 | 100, 0, 0) |
0bcf8261 | 611 | |
1cc17820 JL |
612 | DEFPARAM(PARAM_SINK_FREQUENCY_THRESHOLD, |
613 | "sink-frequency-threshold", | |
a7b2e184 | 614 | "Target block's relative execution frequency (as a percentage) required to sink a statement.", |
1cc17820 JL |
615 | 75, 0, 100) |
616 | ||
f72c6b56 DE |
617 | DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS, |
618 | "max-sched-region-blocks", | |
a7b2e184 | 619 | "The maximum number of blocks in a region to be considered for interblock scheduling.", |
e06c0feb | 620 | 10, 0, 0) |
f72c6b56 DE |
621 | |
622 | DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS, | |
623 | "max-sched-region-insns", | |
a7b2e184 | 624 | "The maximum number of insns in a region to be considered for interblock scheduling.", |
e06c0feb | 625 | 100, 0, 0) |
f72c6b56 | 626 | |
e855c69d AB |
627 | DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS, |
628 | "max-pipeline-region-blocks", | |
a7b2e184 | 629 | "The maximum number of blocks in a region to be considered for interblock scheduling.", |
e855c69d AB |
630 | 15, 0, 0) |
631 | ||
632 | DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS, | |
633 | "max-pipeline-region-insns", | |
a7b2e184 | 634 | "The maximum number of insns in a region to be considered for interblock scheduling.", |
e855c69d AB |
635 | 200, 0, 0) |
636 | ||
6f48c21a PS |
637 | DEFPARAM(PARAM_MIN_SPEC_PROB, |
638 | "min-spec-prob", | |
a7b2e184 | 639 | "The minimum probability of reaching a source block for interblock speculative scheduling.", |
6f48c21a PS |
640 | 40, 0, 0) |
641 | ||
d08eefb9 MK |
642 | DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, |
643 | "max-sched-extend-regions-iters", | |
a7b2e184 | 644 | "The maximum number of iterations through CFG to extend regions.", |
bb83aa4b | 645 | 0, 0, 0) |
d08eefb9 | 646 | |
496d7bb0 MK |
647 | DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY, |
648 | "max-sched-insn-conflict-delay", | |
a7b2e184 | 649 | "The maximum conflict delay for an insn to be considered for speculative motion.", |
496d7bb0 MK |
650 | 3, 1, 10) |
651 | ||
652 | DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF, | |
653 | "sched-spec-prob-cutoff", | |
654 | "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.", | |
655 | 40, 0, 100) | |
656 | ||
975ccf22 BS |
657 | DEFPARAM(PARAM_SCHED_STATE_EDGE_PROB_CUTOFF, |
658 | "sched-state-edge-prob-cutoff", | |
659 | "The minimum probability an edge must have for the scheduler to save its state across it.", | |
660 | 10, 0, 100) | |
661 | ||
e855c69d AB |
662 | DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD, |
663 | "selsched-max-lookahead", | |
a7b2e184 | 664 | "The maximum size of the lookahead window of selective scheduling.", |
e855c69d AB |
665 | 50, 0, 0) |
666 | ||
667 | DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES, | |
668 | "selsched-max-sched-times", | |
a7b2e184 | 669 | "Maximum number of times that an insn could be scheduled.", |
6c12bd5b | 670 | 2, 1, 0) |
e855c69d AB |
671 | |
672 | DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME, | |
673 | "selsched-insns-to-rename", | |
a7b2e184 | 674 | "Maximum number of instructions in the ready list that are considered eligible for renaming.", |
e855c69d AB |
675 | 2, 0, 0) |
676 | ||
677 | DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST, | |
678 | "sched-mem-true-dep-cost", | |
a7b2e184 | 679 | "Minimal distance between possibly conflicting store and load.", |
e855c69d AB |
680 | 1, 0, 0) |
681 | ||
340c7904 MK |
682 | DEFPARAM (PARAM_SCHED_AUTOPREF_QUEUE_DEPTH, |
683 | "sched-autopref-queue-depth", | |
684 | "Hardware autoprefetcher scheduler model control flag. Number of lookahead cycles the model looks into; at '0' only enable instruction sorting heuristic. Disabled by default.", | |
685 | -1, 0, 0) | |
686 | ||
49c3b9a8 JJ |
687 | DEFPARAM(PARAM_MAX_LAST_VALUE_RTL, |
688 | "max-last-value-rtl", | |
a7b2e184 | 689 | "The maximum number of RTL nodes that can be recorded as combiner's last value.", |
49c3b9a8 JJ |
690 | 10000, 0, 0) |
691 | ||
e9a8fc23 RB |
692 | DEFPARAM(PARAM_MAX_COMBINE_INSNS, |
693 | "max-combine-insns", | |
a7b2e184 | 694 | "The maximum number of insns combine tries to combine.", |
e9a8fc23 RB |
695 | 4, 2, 4) |
696 | ||
89b0433e NS |
697 | /* INTEGER_CST nodes are shared for values [{-1,0} .. N) for |
698 | {signed,unsigned} integral types. This determines N. | |
c58c0d4c RG |
699 | Experimentation shows 251 to be a good value that generates the |
700 | least amount of garbage for allocating the TREE_VEC storage. */ | |
89b0433e NS |
701 | DEFPARAM (PARAM_INTEGER_SHARE_LIMIT, |
702 | "integer-share-limit", | |
a7b2e184 | 703 | "The upper bound for sharing integer constants.", |
c58c0d4c | 704 | 251, 2, 2) |
89b0433e | 705 | |
7d69de61 RH |
706 | DEFPARAM (PARAM_SSP_BUFFER_SIZE, |
707 | "ssp-buffer-size", | |
a7b2e184 | 708 | "The lower bound for a buffer to be considered for stack smashing protection.", |
7d69de61 RH |
709 | 8, 1, 0) |
710 | ||
4d5b5e9f ER |
711 | DEFPARAM (PARAM_MIN_SIZE_FOR_STACK_SHARING, |
712 | "min-size-for-stack-sharing", | |
713 | "The minimum size of variables taking part in stack slot sharing " | |
a7b2e184 | 714 | "when not optimizing.", |
4d5b5e9f ER |
715 | 32, 0, 0) |
716 | ||
43f31be5 JL |
717 | /* When we thread through a block we have to make copies of the |
718 | statements within the block. Clearly for large blocks the code | |
719 | duplication is bad. | |
720 | ||
721 | PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS specifies the maximum number | |
722 | of statements and PHI nodes allowed in a block which is going to | |
723 | be duplicated for thread jumping purposes. | |
724 | ||
725 | Some simple analysis showed that more than 99% of the jump | |
726 | threading opportunities are for blocks with less than 15 | |
727 | statements. So we can get the benefits of jump threading | |
728 | without excessive code bloat for pathological cases with the | |
729 | throttle set at 15 statements. */ | |
730 | DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS, | |
731 | "max-jump-thread-duplication-stmts", | |
a7b2e184 | 732 | "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps.", |
43f31be5 | 733 | 15, 0, 0) |
98035a75 DB |
734 | |
735 | /* This is the maximum number of fields a variable may have before the pointer analysis machinery | |
b8698a0f | 736 | will stop trying to treat it in a field-sensitive manner. |
98035a75 DB |
737 | There are programs out there with thousands of fields per structure, and handling them |
738 | field-sensitively is not worth the cost. */ | |
739 | DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE, | |
740 | "max-fields-for-field-sensitive", | |
a7b2e184 | 741 | "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable.", |
d9338cf0 | 742 | 0, 0, 0) |
6f8dd94b EB |
743 | |
744 | DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, | |
745 | "max-sched-ready-insns", | |
a7b2e184 | 746 | "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.", |
6f8dd94b EB |
747 | 100, 0, 0) |
748 | ||
dabd47e7 JJ |
749 | /* This is the maximum number of active local stores RTL DSE will consider. */ |
750 | DEFPARAM (PARAM_MAX_DSE_ACTIVE_LOCAL_STORES, | |
751 | "max-dse-active-local-stores", | |
a7b2e184 | 752 | "Maximum number of active local stores in RTL dead store elimination.", |
dabd47e7 JJ |
753 | 5000, 0, 0) |
754 | ||
47eb5b32 ZD |
755 | /* Prefetching and cache-optimizations related parameters. Default values are |
756 | usually set by machine description. */ | |
757 | ||
758 | /* The number of insns executed before prefetch is completed. */ | |
759 | ||
760 | DEFPARAM (PARAM_PREFETCH_LATENCY, | |
761 | "prefetch-latency", | |
a7b2e184 | 762 | "The number of insns executed before prefetch is completed.", |
47eb5b32 ZD |
763 | 200, 0, 0) |
764 | ||
765 | /* The number of prefetches that can run at the same time. */ | |
766 | ||
767 | DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES, | |
768 | "simultaneous-prefetches", | |
a7b2e184 | 769 | "The number of prefetches that can run at the same time.", |
47eb5b32 ZD |
770 | 3, 0, 0) |
771 | ||
46cb0441 | 772 | /* The size of L1 cache in kB. */ |
47eb5b32 ZD |
773 | |
774 | DEFPARAM (PARAM_L1_CACHE_SIZE, | |
775 | "l1-cache-size", | |
a7b2e184 | 776 | "The size of L1 cache.", |
46cb0441 | 777 | 64, 0, 0) |
47eb5b32 ZD |
778 | |
779 | /* The size of L1 cache line in bytes. */ | |
780 | ||
781 | DEFPARAM (PARAM_L1_CACHE_LINE_SIZE, | |
782 | "l1-cache-line-size", | |
a7b2e184 | 783 | "The size of L1 cache line.", |
47eb5b32 ZD |
784 | 32, 0, 0) |
785 | ||
46cb0441 ZD |
786 | /* The size of L2 cache in kB. */ |
787 | ||
788 | DEFPARAM (PARAM_L2_CACHE_SIZE, | |
789 | "l2-cache-size", | |
a7b2e184 | 790 | "The size of L2 cache.", |
46cb0441 ZD |
791 | 512, 0, 0) |
792 | ||
7313518b DG |
793 | /* Whether we should use canonical types rather than deep "structural" |
794 | type checking. Setting this value to 1 (the default) improves | |
795 | compilation performance in the C++ and Objective-C++ front end; | |
796 | this value should only be set to zero to work around bugs in the | |
797 | canonical type system by disabling it. */ | |
798 | ||
799 | DEFPARAM (PARAM_USE_CANONICAL_TYPES, | |
800 | "use-canonical-types", | |
a7b2e184 | 801 | "Whether to use canonical types.", |
7313518b | 802 | 1, 0, 1) |
f0ed4cfb NC |
803 | |
804 | DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, | |
805 | "max-partial-antic-length", | |
a7b2e184 | 806 | "Maximum length of partial antic set when performing tree pre optimization.", |
f0ed4cfb NC |
807 | 100, 0, 0) |
808 | ||
863d2a57 RG |
809 | /* The following is used as a stop-gap limit for cases where really huge |
810 | SCCs blow up memory and compile-time use too much. If we hit this limit, | |
811 | SCCVN and such FRE and PRE will be not done at all for the current | |
812 | function. */ | |
813 | ||
814 | DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE, | |
815 | "sccvn-max-scc-size", | |
a7b2e184 | 816 | "Maximum size of a SCC before SCCVN stops processing a function.", |
863d2a57 RG |
817 | 10000, 10, 0) |
818 | ||
9bb06c2a RG |
819 | /* The following is used as a stop-gap limit for cases where really huge |
820 | functions blow up compile-time use too much. It limits the number of | |
821 | alias-queries we do for finding common subexpressions for memory loads and | |
822 | stores. The number of alias-queries is otherwise limited by the number of | |
823 | stores on paths to function entry. */ | |
824 | ||
825 | DEFPARAM (PARAM_SCCVN_MAX_ALIAS_QUERIES_PER_ACCESS, | |
826 | "sccvn-max-alias-queries-per-access", | |
a7b2e184 | 827 | "Maximum number of disambiguations to perform per memory access.", |
9bb06c2a RG |
828 | 1000, 0, 0) |
829 | ||
058e97ec VM |
830 | DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM, |
831 | "ira-max-loops-num", | |
a7b2e184 | 832 | "Max loops number for regional RA.", |
30ea859e | 833 | 100, 0, 0) |
058e97ec | 834 | |
311aab06 VM |
835 | DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE, |
836 | "ira-max-conflict-table-size", | |
a7b2e184 | 837 | "Max size of conflict table in MB.", |
7cd06356 | 838 | 1000, 0, 0) |
311aab06 | 839 | |
1833192f VM |
840 | DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS, |
841 | "ira-loop-reserved-regs", | |
a7b2e184 | 842 | "The number of registers in each class kept unused by loop invariant motion.", |
1833192f VM |
843 | 2, 0, 0) |
844 | ||
88def637 VM |
845 | DEFPARAM (PARAM_LRA_MAX_CONSIDERED_RELOAD_PSEUDOS, |
846 | "lra-max-considered-reload-pseudos", | |
a7b2e184 | 847 | "The max number of reload pseudos which are considered during spilling a non-reload pseudo.", |
88def637 VM |
848 | 500, 0, 0) |
849 | ||
fb8a0e40 VM |
850 | DEFPARAM (PARAM_LRA_INHERITANCE_EBB_PROBABILITY_CUTOFF, |
851 | "lra-inheritance-ebb-probability-cutoff", | |
a7b2e184 | 852 | "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA.", |
fb8a0e40 VM |
853 | 40, 0, 100) |
854 | ||
b6e99746 MJ |
855 | /* Switch initialization conversion will refuse to create arrays that are |
856 | bigger than this parameter times the number of switch branches. */ | |
857 | ||
858 | DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO, | |
859 | "switch-conversion-max-branch-ratio", | |
860 | "The maximum ratio between array size and switch branches for " | |
a7b2e184 | 861 | "a switch conversion to take place.", |
b6e99746 MJ |
862 | 8, 1, 0) |
863 | ||
e797c5f2 SP |
864 | /* Size of tiles when doing loop blocking. */ |
865 | ||
866 | DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE, | |
867 | "loop-block-tile-size", | |
a7b2e184 | 868 | "size of tiles for loop blocking.", |
e797c5f2 SP |
869 | 51, 0, 0) |
870 | ||
4e7dd376 SP |
871 | /* Maximal number of parameters that we allow in a SCoP. */ |
872 | ||
873 | DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS, | |
874 | "graphite-max-nb-scop-params", | |
a7b2e184 | 875 | "maximum number of parameters in a SCoP.", |
d2552094 | 876 | 10, 0, 0) |
b6bb0094 | 877 | |
8b76e7fe AK |
878 | /* Maximal number of array references in a scop. */ |
879 | ||
880 | DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP, | |
881 | "graphite-max-arrays-per-scop", | |
a7b2e184 | 882 | "maximum number of arrays per scop.", |
8b76e7fe AK |
883 | 100, 0, 0) |
884 | ||
6b3ebcdd SP |
885 | DEFPARAM (PARAM_MAX_ISL_OPERATIONS, |
886 | "max-isl-operations", | |
e357a5e0 | 887 | "maximum number of isl operations, 0 means unlimited", |
6b3ebcdd SP |
888 | 350000, 0, 0) |
889 | ||
96e2d1d1 RB |
890 | /* For testsuite purposes allow to check for codegen error handling. */ |
891 | DEFPARAM (PARAM_GRAPHITE_ALLOW_CODEGEN_ERRORS, | |
892 | "graphite-allow-codegen-errors", | |
893 | "whether codegen errors should be ICEs when -fchecking.", | |
894 | 0, 0, 1) | |
895 | ||
3881dee9 AB |
896 | /* Avoid data dependence analysis on very large loops. */ |
897 | DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS, | |
898 | "loop-max-datarefs-for-datadeps", | |
a7b2e184 | 899 | "Maximum number of datarefs in loop for building loop data dependencies.", |
3881dee9 AB |
900 | 1000, 0, 0) |
901 | ||
b1fb9f56 JJ |
902 | /* Avoid doing loop invariant motion on very large loops. */ |
903 | ||
904 | DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP, | |
905 | "loop-invariant-max-bbs-in-loop", | |
a7b2e184 | 906 | "Max basic blocks number in loop for loop invariant motion.", |
b1fb9f56 JJ |
907 | 10000, 0, 0) |
908 | ||
2243ba51 XDL |
909 | /* When the parameter is 1, use the internal function id |
910 | to look up for profile data. Otherwise, use a more stable | |
911 | external id based on assembler name and source location. */ | |
912 | DEFPARAM (PARAM_PROFILE_FUNC_INTERNAL_ID, | |
913 | "profile-func-internal-id", | |
a7b2e184 | 914 | "use internal function id in profile lookup.", |
2243ba51 | 915 | 0, 0, 1) |
0a750165 RX |
916 | |
917 | /* When the parameter is 1, track the most frequent N target | |
918 | addresses in indirect-call profile. This disables | |
919 | indirect_call_profiler_v2 which tracks single target. */ | |
920 | DEFPARAM (PARAM_INDIR_CALL_TOPN_PROFILE, | |
921 | "indir-call-topn-profile", | |
a7b2e184 | 922 | "track topn target addresses in indirect-call profile.", |
0a750165 | 923 | 0, 0, 1) |
2243ba51 | 924 | |
a70d6342 IR |
925 | /* Avoid SLP vectorization of large basic blocks. */ |
926 | DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, | |
927 | "slp-max-insns-in-bb", | |
a7b2e184 | 928 | "Maximum number of instructions in basic block to be considered for SLP vectorization.", |
a70d6342 IR |
929 | 1000, 0, 0) |
930 | ||
db34470d GS |
931 | DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO, |
932 | "min-insn-to-prefetch-ratio", | |
7b98c16f | 933 | "Min. ratio of insns to prefetches to enable prefetching for " |
a7b2e184 | 934 | "a loop with an unknown trip count.", |
fe4cd14b | 935 | 9, 0, 0) |
db34470d GS |
936 | |
937 | DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO, | |
938 | "prefetch-min-insn-to-mem-ratio", | |
a7b2e184 | 939 | "Min. ratio of insns to mem ops to enable prefetching in a loop.", |
db34470d GS |
940 | 3, 0, 0) |
941 | ||
ec8c3978 JJ |
942 | /* Set maximum hash table size for var tracking. */ |
943 | ||
944 | DEFPARAM (PARAM_MAX_VARTRACK_SIZE, | |
945 | "max-vartrack-size", | |
a7b2e184 | 946 | "Max. size of var tracking hash tables.", |
ec8c3978 JJ |
947 | 50000000, 0, 0) |
948 | ||
f0686e78 AO |
949 | /* Set maximum recursion depth for var tracking expression expansion |
950 | and resolution. */ | |
951 | ||
952 | DEFPARAM (PARAM_MAX_VARTRACK_EXPR_DEPTH, | |
953 | "max-vartrack-expr-depth", | |
a7b2e184 | 954 | "Max. recursion depth for expanding var tracking expressions.", |
7f8925a1 | 955 | 12, 0, 0) |
f0686e78 | 956 | |
8ab1d2e9 JJ |
957 | /* Set maximum length of value location list for which var tracking |
958 | should add reverse operations. */ | |
959 | ||
960 | DEFPARAM (PARAM_MAX_VARTRACK_REVERSE_OP_SIZE, | |
961 | "max-vartrack-reverse-op-size", | |
a7b2e184 | 962 | "Max. size of loc list for which reverse ops should be added.", |
8ab1d2e9 JJ |
963 | 50, 0, 0) |
964 | ||
b5b8b0ac AO |
965 | /* Set minimum insn uid for non-debug insns. */ |
966 | ||
967 | DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID, | |
968 | "min-nondebug-insn-uid", | |
a7b2e184 | 969 | "The minimum UID to be used for a nondebug insn.", |
91ebcfce | 970 | 0, 0, 0) |
b5b8b0ac | 971 | |
07ffa034 MJ |
972 | DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR, |
973 | "ipa-sra-ptr-growth-factor", | |
7b98c16f | 974 | "Maximum allowed growth of size of new parameters ipa-sra replaces " |
a7b2e184 | 975 | "a pointer to an aggregate with.", |
07ffa034 MJ |
976 | 2, 0, 0) |
977 | ||
0a35513e AH |
978 | DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE, |
979 | "tm-max-aggregate-size", | |
980 | "Size in bytes after which thread-local aggregates should be " | |
981 | "instrumented with the logging functions instead of save/restore " | |
a7b2e184 | 982 | "pairs.", |
0a35513e AH |
983 | 9, 0, 0) |
984 | ||
5a6bc9c7 JG |
985 | DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SPEED, |
986 | "sra-max-scalarization-size-Ospeed", | |
987 | "Maximum size, in storage units, of an aggregate which should be " | |
a7b2e184 | 988 | "considered for scalarization when compiling for speed.", |
5a6bc9c7 JG |
989 | 0, 0, 0) |
990 | ||
991 | DEFPARAM (PARAM_SRA_MAX_SCALARIZATION_SIZE_SIZE, | |
992 | "sra-max-scalarization-size-Osize", | |
993 | "Maximum size, in storage units, of an aggregate which should be " | |
a7b2e184 | 994 | "considered for scalarization when compiling for size.", |
5a6bc9c7 JG |
995 | 0, 0, 0) |
996 | ||
310bc633 MJ |
997 | DEFPARAM (PARAM_IPA_CP_VALUE_LIST_SIZE, |
998 | "ipa-cp-value-list-size", | |
999 | "Maximum size of a list of values associated with each parameter for " | |
a7b2e184 | 1000 | "interprocedural constant propagation.", |
3949c4a7 MJ |
1001 | 8, 0, 0) |
1002 | ||
310bc633 MJ |
1003 | DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD, |
1004 | "ipa-cp-eval-threshold", | |
1005 | "Threshold ipa-cp opportunity evaluation that is still considered " | |
a7b2e184 | 1006 | "beneficial to clone..", |
310bc633 MJ |
1007 | 500, 0, 0) |
1008 | ||
af21714c MJ |
1009 | DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY, |
1010 | "ipa-cp-recursion-penalty", | |
1011 | "Percentage penalty the recursive functions will receive when they " | |
a7b2e184 | 1012 | "are evaluated for cloning..", |
af21714c MJ |
1013 | 40, 0, 100) |
1014 | ||
1015 | DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY, | |
1016 | "ipa-cp-single-call-penalty", | |
bd2c6270 | 1017 | "Percentage penalty functions containing a single call to another " |
a7b2e184 | 1018 | "function will receive when they are evaluated for cloning..", |
af21714c MJ |
1019 | 15, 0, 100) |
1020 | ||
dfea20f1 MJ |
1021 | DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS, |
1022 | "ipa-max-agg-items", | |
1023 | "Maximum number of aggregate content items for a parameter in " | |
a7b2e184 | 1024 | "jump functions and lattices.", |
dfea20f1 MJ |
1025 | 16, 0, 0) |
1026 | ||
2c9561b5 MJ |
1027 | DEFPARAM (PARAM_IPA_CP_LOOP_HINT_BONUS, |
1028 | "ipa-cp-loop-hint-bonus", | |
1029 | "Compile-time bonus IPA-CP assigns to candidates which make loop " | |
a7b2e184 | 1030 | "bounds or strides known..", |
2c9561b5 MJ |
1031 | 64, 0, 0) |
1032 | ||
19321415 MJ |
1033 | DEFPARAM (PARAM_IPA_CP_ARRAY_INDEX_HINT_BONUS, |
1034 | "ipa-cp-array-index-hint-bonus", | |
1035 | "Compile-time bonus IPA-CP assigns to candidates which make an array " | |
a7b2e184 | 1036 | "index known..", |
19321415 MJ |
1037 | 48, 0, 0) |
1038 | ||
8aab5218 MJ |
1039 | DEFPARAM (PARAM_IPA_MAX_AA_STEPS, |
1040 | "ipa-max-aa-steps", | |
1041 | "Maximum number of statements that will be visited by IPA formal " | |
a7b2e184 | 1042 | "parameter analysis based on alias analysis in any given function.", |
8aab5218 MJ |
1043 | 25000, 0, 0) |
1044 | ||
852e4bd2 JH |
1045 | /* WHOPR partitioning configuration. */ |
1046 | ||
1047 | DEFPARAM (PARAM_LTO_PARTITIONS, | |
1048 | "lto-partitions", | |
a7b2e184 | 1049 | "Number of partitions the program should be split to.", |
9bfbc1eb | 1050 | 32, 1, 0) |
852e4bd2 JH |
1051 | |
1052 | DEFPARAM (MIN_PARTITION_SIZE, | |
1053 | "lto-min-partition", | |
a7b2e184 | 1054 | "Minimal size of a partition for LTO (in estimated instructions).", |
4245b087 | 1055 | 10000, 0, 0) |
501c95ff | 1056 | |
a2e76867 PK |
1057 | DEFPARAM (MAX_PARTITION_SIZE, |
1058 | "lto-max-partition", | |
1059 | "Maximal size of a partition for LTO (in estimated instructions).", | |
1060 | 1000000, 0, INT_MAX) | |
1061 | ||
501c95ff NF |
1062 | /* Diagnostic parameters. */ |
1063 | ||
1064 | DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP, | |
1065 | "cxx-max-namespaces-for-diagnostic-help", | |
1066 | "Maximum number of namespaces to search for alternatives when " | |
a7b2e184 | 1067 | "name lookup fails.", |
501c95ff NF |
1068 | 1000, 0, 0) |
1069 | ||
bfe068c3 IR |
1070 | /* Maximum number of conditional store pairs that can be sunk. */ |
1071 | DEFPARAM (PARAM_MAX_STORES_TO_SINK, | |
1072 | "max-stores-to-sink", | |
a7b2e184 | 1073 | "Maximum number of conditional store pairs that can be sunk.", |
bfe068c3 IR |
1074 | 2, 0, 0) |
1075 | ||
3aa439ed MM |
1076 | /* Override CASE_VALUES_THRESHOLD of when to switch from doing switch |
1077 | statements via if statements to using a table jump operation. If the value | |
1078 | is 0, the default CASE_VALUES_THRESHOLD will be used. */ | |
1079 | DEFPARAM (PARAM_CASE_VALUES_THRESHOLD, | |
1080 | "case-values-threshold", | |
1081 | "The smallest number of different values for which it is best to " | |
1082 | "use a jump-table instead of a tree of conditional branches, " | |
a7b2e184 | 1083 | "if 0, use the default for the machine.", |
3aa439ed MM |
1084 | 0, 0, 0) |
1085 | ||
1169e45d AH |
1086 | /* Data race flags for C++0x memory model compliance. */ |
1087 | DEFPARAM (PARAM_ALLOW_STORE_DATA_RACES, | |
1088 | "allow-store-data-races", | |
a7b2e184 | 1089 | "Allow new data races on stores to be introduced.", |
680a5a7c | 1090 | 0, 0, 1) |
86951993 | 1091 | |
df7b0cc4 EI |
1092 | /* Reassociation width to be used by tree reassoc optimization. */ |
1093 | DEFPARAM (PARAM_TREE_REASSOC_WIDTH, | |
1094 | "tree-reassoc-width", | |
1095 | "Set the maximum number of instructions executed in parallel in " | |
a7b2e184 | 1096 | "reassociated tree. If 0, use the target dependent heuristic..", |
df7b0cc4 EI |
1097 | 0, 0, 0) |
1098 | ||
c9e93168 TV |
1099 | DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS, |
1100 | "max-tail-merge-comparisons", | |
a7b2e184 | 1101 | "Maximum amount of similar bbs to compare a bb with.", |
c9e93168 TV |
1102 | 10, 0, 0) |
1103 | ||
f663d9ad KT |
1104 | DEFPARAM (PARAM_STORE_MERGING_ALLOW_UNALIGNED, |
1105 | "store-merging-allow-unaligned", | |
1106 | "Allow the store merging pass to introduce unaligned stores " | |
c242d615 | 1107 | "if it is legal to do so.", |
f663d9ad KT |
1108 | 1, 0, 1) |
1109 | ||
1110 | DEFPARAM (PARAM_MAX_STORES_TO_MERGE, | |
1111 | "max-stores-to-merge", | |
0fc08a17 | 1112 | "Maximum number of constant stores to merge in the " |
c242d615 | 1113 | "store merging pass.", |
f663d9ad KT |
1114 | 64, 2, 0) |
1115 | ||
c9e93168 TV |
1116 | DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS, |
1117 | "max-tail-merge-iterations", | |
a7b2e184 | 1118 | "Maximum amount of iterations of the pass over a function.", |
c9e93168 | 1119 | 2, 0, 0) |
bfe068c3 | 1120 | |
19ecbcbc JJ |
1121 | /* Maximum number of strings for which strlen optimization pass will |
1122 | track string lenths. */ | |
1123 | DEFPARAM (PARAM_MAX_TRACKED_STRLENS, | |
1124 | "max-tracked-strlens", | |
1125 | "Maximum number of strings for which strlen optimization pass will " | |
a7b2e184 | 1126 | "track string lengths.", |
204a913b | 1127 | 10000, 0, 0) |
19ecbcbc | 1128 | |
c881de02 RS |
1129 | /* Keep this in sync with the sched_pressure_algorithm enum. */ |
1130 | DEFPARAM (PARAM_SCHED_PRESSURE_ALGORITHM, | |
1131 | "sched-pressure-algorithm", | |
a7b2e184 | 1132 | "Which -fsched-pressure algorithm to apply.", |
c881de02 RS |
1133 | 1, 1, 2) |
1134 | ||
ccdbfe93 BS |
1135 | /* Maximum length of candidate scans in straight-line strength reduction. */ |
1136 | DEFPARAM (PARAM_MAX_SLSR_CANDIDATE_SCAN, | |
1137 | "max-slsr-cand-scan", | |
1138 | "Maximum length of candidate scans for straight-line " | |
a7b2e184 | 1139 | "strength reduction.", |
ccdbfe93 BS |
1140 | 50, 1, 999999) |
1141 | ||
b5ebc991 MO |
1142 | DEFPARAM (PARAM_ASAN_STACK, |
1143 | "asan-stack", | |
a7b2e184 | 1144 | "Enable asan stack protection.", |
b5ebc991 MO |
1145 | 1, 0, 1) |
1146 | ||
5094f7d5 MO |
1147 | DEFPARAM (PARAM_ASAN_PROTECT_ALLOCAS, |
1148 | "asan-instrument-allocas", | |
1149 | "Enable asan allocas/VLAs protection.", | |
1150 | 1, 0, 1) | |
1151 | ||
b5ebc991 MO |
1152 | DEFPARAM (PARAM_ASAN_GLOBALS, |
1153 | "asan-globals", | |
a7b2e184 | 1154 | "Enable asan globals protection.", |
b5ebc991 MO |
1155 | 1, 0, 1) |
1156 | ||
1157 | DEFPARAM (PARAM_ASAN_INSTRUMENT_WRITES, | |
1158 | "asan-instrument-writes", | |
a7b2e184 | 1159 | "Enable asan store operations protection.", |
b5ebc991 MO |
1160 | 1, 0, 1) |
1161 | ||
1162 | DEFPARAM (PARAM_ASAN_INSTRUMENT_READS, | |
1163 | "asan-instrument-reads", | |
a7b2e184 | 1164 | "Enable asan load operations protection.", |
b5ebc991 MO |
1165 | 1, 0, 1) |
1166 | ||
1167 | DEFPARAM (PARAM_ASAN_MEMINTRIN, | |
1168 | "asan-memintrin", | |
a7b2e184 | 1169 | "Enable asan builtin functions protection.", |
b5ebc991 MO |
1170 | 1, 0, 1) |
1171 | ||
1172 | DEFPARAM (PARAM_ASAN_USE_AFTER_RETURN, | |
1173 | "asan-use-after-return", | |
a7b2e184 | 1174 | "Enable asan detection of use-after-return bugs.", |
b5ebc991 | 1175 | 1, 0, 1) |
92261ce0 | 1176 | |
8946c29e YG |
1177 | DEFPARAM (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD, |
1178 | "asan-instrumentation-with-call-threshold", | |
c62ccb9a | 1179 | "Use callbacks instead of inline code if number of accesses " |
a7b2e184 | 1180 | "in function becomes greater or equal to this number.", |
c62ccb9a | 1181 | 7000, 0, INT_MAX) |
8946c29e | 1182 | |
6dc4a604 ML |
1183 | DEFPARAM (PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD, |
1184 | "use-after-scope-direct-emission-threshold", | |
bd2c6270 | 1185 | "Use direct poisoning/unpoisoning instructions for variables " |
6dc4a604 ML |
1186 | "smaller or equal to this number.", |
1187 | 256, 0, INT_MAX) | |
1188 | ||
92261ce0 JJ |
1189 | DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS, |
1190 | "uninit-control-dep-attempts", | |
1191 | "Maximum number of nested calls to search for control dependencies " | |
a7b2e184 | 1192 | "during uninitialized variable analysis.", |
92261ce0 | 1193 | 1000, 1, 0) |
d5e254e1 IE |
1194 | |
1195 | DEFPARAM (PARAM_CHKP_MAX_CTOR_SIZE, | |
1196 | "chkp-max-ctor-size", | |
1197 | "Maximum number of statements to be included into a single static " | |
a7b2e184 | 1198 | "constructor generated by Pointer Bounds Checker.", |
d5e254e1 | 1199 | 5000, 100, 0) |
50e9ff83 | 1200 | |
2b572b3c JL |
1201 | DEFPARAM (PARAM_FSM_SCALE_PATH_STMTS, |
1202 | "fsm-scale-path-stmts", | |
1203 | "Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks.", | |
1204 | 2, 1, 10) | |
1205 | ||
da9a8da8 JL |
1206 | DEFPARAM (PARAM_FSM_MAXIMUM_PHI_ARGUMENTS, |
1207 | "fsm-maximum-phi-arguments", | |
1208 | "Maximum number of arguments a PHI may have before the FSM threader will not try to thread through its block.", | |
1209 | 100, 1, 999999) | |
1210 | ||
2b572b3c JL |
1211 | DEFPARAM (PARAM_FSM_SCALE_PATH_BLOCKS, |
1212 | "fsm-scale-path-blocks", | |
1213 | "Scale factor to apply to the number of blocks in a threading path when comparing to the number of (scaled) statements.", | |
1214 | 3, 1, 10) | |
1215 | ||
50e9ff83 JG |
1216 | DEFPARAM (PARAM_MAX_FSM_THREAD_PATH_INSNS, |
1217 | "max-fsm-thread-path-insns", | |
a7b2e184 | 1218 | "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path.", |
50e9ff83 JG |
1219 | 100, 1, 999999) |
1220 | ||
1221 | DEFPARAM (PARAM_MAX_FSM_THREAD_LENGTH, | |
1222 | "max-fsm-thread-length", | |
a7b2e184 | 1223 | "Maximum number of basic blocks on a finite state automaton jump thread path.", |
50e9ff83 JG |
1224 | 10, 1, 999999) |
1225 | ||
1226 | DEFPARAM (PARAM_MAX_FSM_THREAD_PATHS, | |
1227 | "max-fsm-thread-paths", | |
a7b2e184 | 1228 | "Maximum number of new jump thread paths to create for a finite state automaton.", |
50e9ff83 | 1229 | 50, 1, 999999) |
f7f18684 TV |
1230 | |
1231 | DEFPARAM (PARAM_PARLOOPS_CHUNK_SIZE, | |
1232 | "parloops-chunk-size", | |
a7b2e184 | 1233 | "Chunk size of omp schedule for loops parallelized by parloops.", |
f7f18684 | 1234 | 0, 0, 0) |
68e57f04 | 1235 | |
1f600fea TV |
1236 | DEFPARAMENUM5 (PARAM_PARLOOPS_SCHEDULE, |
1237 | "parloops-schedule", | |
1238 | "Schedule type of omp schedule for loops parallelized by " | |
a7b2e184 | 1239 | "parloops (static, dynamic, guided, auto, runtime).", |
1f600fea TV |
1240 | static, |
1241 | static, dynamic, guided, auto, runtime) | |
1242 | ||
68e57f04 RS |
1243 | DEFPARAM (PARAM_MAX_SSA_NAME_QUERY_DEPTH, |
1244 | "max-ssa-name-query-depth", | |
1245 | "Maximum recursion depth allowed when querying a property of an" | |
a7b2e184 | 1246 | " SSA name.", |
830afa4b | 1247 | 3, 1, 10) |
ca90b1ed YR |
1248 | |
1249 | DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_INSNS, | |
1250 | "max-rtl-if-conversion-insns", | |
1251 | "Maximum number of insns in a basic block to consider for RTL " | |
1252 | "if-conversion.", | |
1253 | 10, 0, 99) | |
b2b40051 | 1254 | |
e914c11a JG |
1255 | DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_PREDICTABLE_COST, |
1256 | "max-rtl-if-conversion-predictable-cost", | |
1257 | "Maximum permissible cost for the sequence that would be " | |
1258 | "generated by the RTL if-conversion pass for a branch that " | |
1259 | "is considered predictable.", | |
1260 | 20, 0, 200) | |
1261 | ||
1262 | DEFPARAM (PARAM_MAX_RTL_IF_CONVERSION_UNPREDICTABLE_COST, | |
1263 | "max-rtl-if-conversion-unpredictable-cost", | |
1264 | "Maximum permissible cost for the sequence that would be " | |
1265 | "generated by the RTL if-conversion pass for a branch that " | |
1266 | "is considered unpredictable.", | |
1267 | 40, 0, 200) | |
1268 | ||
b2b40051 MJ |
1269 | DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES, |
1270 | "hsa-gen-debug-stores", | |
1271 | "Level of hsa debug stores verbosity", | |
1272 | 0, 0, 1) | |
9c49362f MM |
1273 | |
1274 | DEFPARAM (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS, | |
1275 | "max-speculative-devirt-maydefs", | |
1276 | "Maximum number of may-defs visited when devirtualizing " | |
1277 | "speculatively", 50, 0, 0) | |
1278 | ||
524cf1e4 PP |
1279 | DEFPARAM (PARAM_MAX_VRP_SWITCH_ASSERTIONS, |
1280 | "max-vrp-switch-assertions", | |
1281 | "Maximum number of assertions to add along the default " | |
1282 | "edge of a switch statement during VRP", | |
1283 | 10, 0, 0) | |
1284 | ||
598eaaa2 YR |
1285 | DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK, |
1286 | "vect-epilogues-nomask", | |
1287 | "Enable loop epilogue vectorization using smaller vector size.", | |
1288 | 0, 0, 1) | |
1289 | ||
c6d9a88c | 1290 | /* |
b5ebc991 | 1291 | |
c6d9a88c MM |
1292 | Local variables: |
1293 | mode:c | |
f4b4a3e2 NC |
1294 | End: |
1295 | */ |