comparison gcc/params.def @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* params.def - Run-time parameters. 1 /* params.def - Run-time parameters.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 2011
4 Free Software Foundation, Inc.
5 Written by Mark Mitchell <mark@codesourcery.com>. 3 Written by Mark Mitchell <mark@codesourcery.com>.
6 4
7 This file is part of GCC. 5 This file is part of GCC.
8 6
9 GCC is free software; you can redistribute it and/or modify it under 7 GCC is free software; you can redistribute it and/or modify it under
35 - The minimum acceptable value for the parameter. 33 - The minimum acceptable value for the parameter.
36 34
37 - The maximum acceptable value for the parameter (if greater than 35 - The maximum acceptable value for the parameter (if greater than
38 the minimum). 36 the minimum).
39 37
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
40 Be sure to add an entry to invoke.texi summarizing the parameter. */ 43 Be sure to add an entry to invoke.texi summarizing the parameter. */
41
42 /* The threshold ratio between current and hottest structure counts.
43 We say that if the ratio of the current structure count,
44 calculated by profiling, to the hottest structure count
45 in the program is less than this parameter, then structure
46 reorganization is not applied. The default is 10%. */
47 DEFPARAM (PARAM_STRUCT_REORG_COLD_STRUCT_RATIO,
48 "struct-reorg-cold-struct-ratio",
49 "The threshold ratio between current and hottest structure counts",
50 10, 0, 100)
51 44
52 /* When branch is predicted to be taken with probability lower than this 45 /* When branch is predicted to be taken with probability lower than this
53 threshold (in percent), then it is considered well predictable. */ 46 threshold (in percent), then it is considered well predictable. */
54 DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME, 47 DEFPARAM (PARAM_PREDICTABLE_BRANCH_OUTCOME,
55 "predictable-branch-outcome", 48 "predictable-branch-outcome",
56 "Maximal estimated outcome of branch considered predictable", 49 "Maximal estimated outcome of branch considered predictable.",
57 2, 0, 50) 50 2, 0, 50)
51
52 DEFPARAM (PARAM_INLINE_MIN_SPEEDUP,
53 "inline-min-speedup",
54 "The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto.",
55 8, 0, 0)
58 56
59 /* The single function inlining limit. This is the maximum size 57 /* The single function inlining limit. This is the maximum size
60 of a function counted in internal gcc instructions (not in 58 of a function counted in internal gcc instructions (not in
61 real machine instructions) that is eligible for inlining 59 real machine instructions) that is eligible for inlining
62 by the tree inliner. 60 by the tree inliner.
68 counted and once the recursive inline limit (see 66 counted and once the recursive inline limit (see
69 "max-inline-insns" parameter) is exceeded, the acceptable size 67 "max-inline-insns" parameter) is exceeded, the acceptable size
70 gets decreased. */ 68 gets decreased. */
71 DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE, 69 DEFPARAM (PARAM_MAX_INLINE_INSNS_SINGLE,
72 "max-inline-insns-single", 70 "max-inline-insns-single",
73 "The maximum number of instructions in a single function eligible for inlining", 71 "The maximum number of instructions in a single function eligible for inlining.",
74 400, 0, 0) 72 400, 0, 0)
75 73
76 /* The single function inlining limit for functions that are 74 /* The single function inlining limit for functions that are
77 inlined by virtue of -finline-functions (-O3). 75 inlined by virtue of -finline-functions (-O3).
78 This limit should be chosen to be below or equal to the limit 76 This limit should be chosen to be below or equal to the limit
80 class declaration in C++) given by the "max-inline-insns-single" 78 class declaration in C++) given by the "max-inline-insns-single"
81 parameter. 79 parameter.
82 The default value is 40. */ 80 The default value is 40. */
83 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO, 81 DEFPARAM (PARAM_MAX_INLINE_INSNS_AUTO,
84 "max-inline-insns-auto", 82 "max-inline-insns-auto",
85 "The maximum number of instructions when automatically inlining", 83 "The maximum number of instructions when automatically inlining.",
86 40, 0, 0) 84 40, 0, 0)
87 85
88 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE, 86 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE,
89 "max-inline-insns-recursive", 87 "max-inline-insns-recursive",
90 "The maximum number of instructions inline function can grow to via recursive inlining", 88 "The maximum number of instructions inline function can grow to via recursive inlining.",
91 450, 0, 0) 89 450, 0, 0)
92 90
93 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO, 91 DEFPARAM (PARAM_MAX_INLINE_INSNS_RECURSIVE_AUTO,
94 "max-inline-insns-recursive-auto", 92 "max-inline-insns-recursive-auto",
95 "The maximum number of instructions non-inline function can grow to via recursive inlining", 93 "The maximum number of instructions non-inline function can grow to via recursive inlining.",
96 450, 0, 0) 94 450, 0, 0)
97 95
98 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH, 96 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH,
99 "max-inline-recursive-depth", 97 "max-inline-recursive-depth",
100 "The maximum depth of recursive inlining for inline functions", 98 "The maximum depth of recursive inlining for inline functions.",
101 8, 0, 0) 99 8, 0, 0)
102 100
103 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO, 101 DEFPARAM (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO,
104 "max-inline-recursive-depth-auto", 102 "max-inline-recursive-depth-auto",
105 "The maximum depth of recursive inlining for non-inline functions", 103 "The maximum depth of recursive inlining for non-inline functions.",
106 8, 0, 0) 104 8, 0, 0)
107 105
108 DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY, 106 DEFPARAM (PARAM_MIN_INLINE_RECURSIVE_PROBABILITY,
109 "min-inline-recursive-probability", 107 "min-inline-recursive-probability",
110 "Inline recursively only when the probability of call being executed exceeds the parameter", 108 "Inline recursively only when the probability of call being executed exceeds the parameter.",
111 10, 0, 0) 109 10, 0, 0)
112 110
113 /* Limit of iterations of early inliner. This basically bounds number of 111 /* Limit of iterations of early inliner. This basically bounds number of
114 nested indirect calls early inliner can resolve. Deeper chains are still 112 nested indirect calls early inliner can resolve. Deeper chains are still
115 handled by late inlining. */ 113 handled by late inlining. */
116 DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS, 114 DEFPARAM (PARAM_EARLY_INLINER_MAX_ITERATIONS,
117 "max-early-inliner-iterations", 115 "max-early-inliner-iterations",
118 "The maximum number of nested indirect inlining performed by early inliner", 116 "The maximum number of nested indirect inlining performed by early inliner.",
119 10, 0, 0) 117 1, 0, 0)
120 118
121 /* Limit on probability of entry BB. */ 119 /* Limit on probability of entry BB. */
122 DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY, 120 DEFPARAM (PARAM_COMDAT_SHARING_PROBABILITY,
123 "comdat-sharing-probability", 121 "comdat-sharing-probability",
124 "Probability that COMDAT function will be shared with different compilatoin unit", 122 "Probability that COMDAT function will be shared with different compilation unit.",
125 20, 0, 0) 123 20, 0, 0)
126 124
127 /* Limit on probability of entry BB. */ 125 /* Limit on probability of entry BB. */
128 DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY, 126 DEFPARAM (PARAM_PARTIAL_INLINING_ENTRY_PROBABILITY,
129 "partial-inlining-entry-probability", 127 "partial-inlining-entry-probability",
130 "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen", 128 "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen.",
131 70, 0, 0) 129 70, 0, 100)
132 130
133 /* Limit the number of expansions created by the variable expansion 131 /* Limit the number of expansions created by the variable expansion
134 optimization to avoid register pressure. */ 132 optimization to avoid register pressure. */
135 DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS, 133 DEFPARAM (PARAM_MAX_VARIABLE_EXPANSIONS,
136 "max-variable-expansions-in-unroller", 134 "max-variable-expansions-in-unroller",
137 "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling", 135 "If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling.",
138 1, 0, 0) 136 1, 0, 0)
139 137
140 /* Limit loop autovectorization to loops with large enough iteration count. */ 138 /* Limit loop autovectorization to loops with large enough iteration count. */
141 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND, 139 DEFPARAM (PARAM_MIN_VECT_LOOP_BOUND,
142 "min-vect-loop-bound", 140 "min-vect-loop-bound",
143 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization", 141 "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization.",
144 1, 1, 0) 142 1, 1, 0)
145 143
146 /* The maximum number of instructions to consider when looking for an 144 /* The maximum number of instructions to consider when looking for an
147 instruction to fill a delay slot. If more than this arbitrary 145 instruction to fill a delay slot. If more than this arbitrary
148 number of instructions is searched, the time savings from filling 146 number of instructions is searched, the time savings from filling
149 the delay slot will be minimal so stop searching. Increasing 147 the delay slot will be minimal so stop searching. Increasing
150 values mean more aggressive optimization, making the compile time 148 values mean more aggressive optimization, making the compile time
151 increase with probably small improvement in executable run time. */ 149 increase with probably small improvement in executable run time. */
152 DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH, 150 DEFPARAM (PARAM_MAX_DELAY_SLOT_INSN_SEARCH,
153 "max-delay-slot-insn-search", 151 "max-delay-slot-insn-search",
154 "The maximum number of instructions to consider to fill a delay slot", 152 "The maximum number of instructions to consider to fill a delay slot.",
155 100, 0, 0) 153 100, 0, 0)
156 154
157 /* When trying to fill delay slots, the maximum number of instructions 155 /* When trying to fill delay slots, the maximum number of instructions
158 to consider when searching for a block with valid live register 156 to consider when searching for a block with valid live register
159 information. Increasing this arbitrarily chosen value means more 157 information. Increasing this arbitrarily chosen value means more
160 aggressive optimization, increasing the compile time. This 158 aggressive optimization, increasing the compile time. This
161 parameter should be removed when the delay slot code is rewritten 159 parameter should be removed when the delay slot code is rewritten
162 to maintain the control-flow graph. */ 160 to maintain the control-flow graph. */
163 DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH, 161 DEFPARAM(PARAM_MAX_DELAY_SLOT_LIVE_SEARCH,
164 "max-delay-slot-live-search", 162 "max-delay-slot-live-search",
165 "The maximum number of instructions to consider to find accurate live register information", 163 "The maximum number of instructions to consider to find accurate live register information.",
166 333, 0, 0) 164 333, 0, 0)
167 165
168 /* This parameter limits the number of branch elements that the 166 /* This parameter limits the number of branch elements that the
169 scheduler will track anti-dependencies through without resetting 167 scheduler will track anti-dependencies through without resetting
170 the tracking mechanism. Large functions with few calls or barriers 168 the tracking mechanism. Large functions with few calls or barriers
171 can generate lists containing many 1000's of dependencies. Generally 169 can generate lists containing many 1000's of dependencies. Generally
172 the compiler either uses all available memory, or runs for far too long. */ 170 the compiler either uses all available memory, or runs for far too long. */
173 DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH, 171 DEFPARAM(PARAM_MAX_PENDING_LIST_LENGTH,
174 "max-pending-list-length", 172 "max-pending-list-length",
175 "The maximum length of scheduling's pending operations list", 173 "The maximum length of scheduling's pending operations list.",
176 32, 0, 0) 174 32, 0, 0)
175
176 /* This parameter limits the number of backtracking attempts when using the
177 haifa scheduler for modulo scheduling. */
178 DEFPARAM(PARAM_MAX_MODULO_BACKTRACK_ATTEMPTS,
179 "max-modulo-backtrack-attempts",
180 "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop.",
181 40, 0, 0)
177 182
178 DEFPARAM(PARAM_LARGE_FUNCTION_INSNS, 183 DEFPARAM(PARAM_LARGE_FUNCTION_INSNS,
179 "large-function-insns", 184 "large-function-insns",
180 "The size of function body to be considered large", 185 "The size of function body to be considered large.",
181 2700, 0, 0) 186 2700, 0, 0)
182 DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH, 187 DEFPARAM(PARAM_LARGE_FUNCTION_GROWTH,
183 "large-function-growth", 188 "large-function-growth",
184 "Maximal growth due to inlining of large function (in percent)", 189 "Maximal growth due to inlining of large function (in percent).",
185 100, 0, 0) 190 100, 0, 0)
186 DEFPARAM(PARAM_LARGE_UNIT_INSNS, 191 DEFPARAM(PARAM_LARGE_UNIT_INSNS,
187 "large-unit-insns", 192 "large-unit-insns",
188 "The size of translation unit to be considered large", 193 "The size of translation unit to be considered large.",
189 10000, 0, 0) 194 10000, 0, 0)
190 DEFPARAM(PARAM_INLINE_UNIT_GROWTH, 195 DEFPARAM(PARAM_INLINE_UNIT_GROWTH,
191 "inline-unit-growth", 196 "inline-unit-growth",
192 "How much can given compilation unit grow because of the inlining (in percent)", 197 "How much can given compilation unit grow because of the inlining (in percent).",
193 30, 0, 0) 198 20, 0, 0)
194 DEFPARAM(PARAM_IPCP_UNIT_GROWTH, 199 DEFPARAM(PARAM_IPCP_UNIT_GROWTH,
195 "ipcp-unit-growth", 200 "ipcp-unit-growth",
196 "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)", 201 "How much can given compilation unit grow because of the interprocedural constant propagation (in percent).",
197 10, 0, 0) 202 10, 0, 0)
198 DEFPARAM(PARAM_EARLY_INLINING_INSNS, 203 DEFPARAM(PARAM_EARLY_INLINING_INSNS,
199 "early-inlining-insns", 204 "early-inlining-insns",
200 "Maximal estimated growth of function body caused by early inlining of single call", 205 "Maximal estimated growth of function body caused by early inlining of single call.",
201 10, 0, 0) 206 14, 0, 0)
202 DEFPARAM(PARAM_LARGE_STACK_FRAME, 207 DEFPARAM(PARAM_LARGE_STACK_FRAME,
203 "large-stack-frame", 208 "large-stack-frame",
204 "The size of stack frame to be considered large", 209 "The size of stack frame to be considered large.",
205 256, 0, 0) 210 256, 0, 0)
206 DEFPARAM(PARAM_STACK_FRAME_GROWTH, 211 DEFPARAM(PARAM_STACK_FRAME_GROWTH,
207 "large-stack-frame-growth", 212 "large-stack-frame-growth",
208 "Maximal stack frame growth due to inlining (in percent)", 213 "Maximal stack frame growth due to inlining (in percent).",
209 1000, 0, 0) 214 1000, 0, 0)
215
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)
210 225
211 /* The GCSE optimization will be disabled if it would require 226 /* The GCSE optimization will be disabled if it would require
212 significantly more memory than this value. */ 227 significantly more memory than this value. */
213 DEFPARAM(PARAM_MAX_GCSE_MEMORY, 228 DEFPARAM(PARAM_MAX_GCSE_MEMORY,
214 "max-gcse-memory", 229 "max-gcse-memory",
215 "The maximum amount of memory to be allocated by GCSE", 230 "The maximum amount of memory to be allocated by GCSE.",
216 50 * 1024 * 1024, 0, 0) 231 128 * 1024 * 1024, 0, 0)
217 232
218 /* The GCSE optimization of an expression will avoided if the ratio of 233 /* The GCSE optimization of an expression will avoided if the ratio of
219 insertions to deletions is greater than this value. */ 234 insertions to deletions is greater than this value. */
220 DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO, 235 DEFPARAM(PARAM_MAX_GCSE_INSERTION_RATIO,
221 "max-gcse-insertion-ratio", 236 "max-gcse-insertion-ratio",
222 "The maximum ratio of insertions to deletions of expressions in GCSE", 237 "The maximum ratio of insertions to deletions of expressions in GCSE.",
223 20, 0, 0) 238 20, 0, 0)
224 239
225 /* This is the threshold ratio when to perform partial redundancy 240 /* This is the threshold ratio when to perform partial redundancy
226 elimination after reload. We perform partial redundancy elimination 241 elimination after reload. We perform partial redundancy elimination
227 when the following holds: 242 when the following holds:
228 (Redundant load execution count) 243 (Redundant load execution count)
229 ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION 244 ------------------------------- >= GCSE_AFTER_RELOAD_PARTIAL_FRACTION
230 (Added loads execution count) */ 245 (Added loads execution count) */
231 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION, 246 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_PARTIAL_FRACTION,
232 "gcse-after-reload-partial-fraction", 247 "gcse-after-reload-partial-fraction",
233 "The threshold ratio for performing partial redundancy elimination after reload", 248 "The threshold ratio for performing partial redundancy elimination after reload.",
234 3, 0, 0) 249 3, 0, 0)
235 /* This is the threshold ratio of the critical edges execution count compared to 250 /* This is the threshold ratio of the critical edges execution count compared to
236 the redundant loads execution count that permits performing the load 251 the redundant loads execution count that permits performing the load
237 redundancy elimination in gcse after reload. */ 252 redundancy elimination in gcse after reload. */
238 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION, 253 DEFPARAM(PARAM_GCSE_AFTER_RELOAD_CRITICAL_FRACTION,
239 "gcse-after-reload-critical-fraction", 254 "gcse-after-reload-critical-fraction",
240 "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload", 255 "The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload.",
241 10, 0, 0) 256 10, 0, 0)
242 257
243 /* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor 258 /* GCSE will use GCSE_COST_DISTANCE_RATION as a scaling factor
244 to calculate maximum distance for which an expression is allowed to move 259 to calculate maximum distance for which an expression is allowed to move
245 from its rtx_cost. */ 260 from its rtx_cost. */
246 DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO, 261 DEFPARAM(PARAM_GCSE_COST_DISTANCE_RATIO,
247 "gcse-cost-distance-ratio", 262 "gcse-cost-distance-ratio",
248 "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations", 263 "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations.",
249 10, 0, 0) 264 10, 0, 0)
250 /* GCSE won't restrict distance for which an expression with rtx_cost greater 265 /* GCSE won't restrict distance for which an expression with rtx_cost greater
251 than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */ 266 than COSTS_N_INSN(GCSE_UNRESTRICTED_COST) is allowed to move. */
252 DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST, 267 DEFPARAM(PARAM_GCSE_UNRESTRICTED_COST,
253 "gcse-unrestricted-cost", 268 "gcse-unrestricted-cost",
254 "Cost at which GCSE optimizations will not constraint the distance an expression can travel", 269 "Cost at which GCSE optimizations will not constraint the distance an expression can travel.",
255 3, 0, 0) 270 3, 0, 0)
256 271
257 /* How deep from a given basic block the dominator tree should be searched 272 /* How deep from a given basic block the dominator tree should be searched
258 for expressions to hoist to the block. The value of 0 will avoid limiting 273 for expressions to hoist to the block. The value of 0 will avoid limiting
259 the search. */ 274 the search. */
260 DEFPARAM(PARAM_MAX_HOIST_DEPTH, 275 DEFPARAM(PARAM_MAX_HOIST_DEPTH,
261 "max-hoist-depth", 276 "max-hoist-depth",
262 "Maximum depth of search in the dominator tree for expressions to hoist", 277 "Maximum depth of search in the dominator tree for expressions to hoist.",
263 30, 0, 0) 278 30, 0, 0)
279
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",
285 "Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant.",
286 5, 1, 32)
264 287
265 /* This parameter limits the number of insns in a loop that will be unrolled, 288 /* This parameter limits the number of insns in a loop that will be unrolled,
266 and by how much the loop is unrolled. 289 and by how much the loop is unrolled.
267 290
268 This limit should be at most half of the peeling limits: loop unroller 291 This limit should be at most half of the peeling limits: loop unroller
269 decides to not unroll loops that iterate fewer than 2*number of allowed 292 decides to not unroll loops that iterate fewer than 2*number of allowed
270 unrollings and thus we would have loops that are neither peeled or unrolled 293 unrollings and thus we would have loops that are neither peeled or unrolled
271 otherwise. */ 294 otherwise. */
272 DEFPARAM(PARAM_MAX_UNROLLED_INSNS, 295 DEFPARAM(PARAM_MAX_UNROLLED_INSNS,
273 "max-unrolled-insns", 296 "max-unrolled-insns",
274 "The maximum number of instructions to consider to unroll in a loop", 297 "The maximum number of instructions to consider to unroll in a loop.",
275 200, 0, 0) 298 200, 0, 0)
276 /* This parameter limits how many times the loop is unrolled depending 299 /* This parameter limits how many times the loop is unrolled depending
277 on number of insns really executed in each iteration. */ 300 on number of insns really executed in each iteration. */
278 DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS, 301 DEFPARAM(PARAM_MAX_AVERAGE_UNROLLED_INSNS,
279 "max-average-unrolled-insns", 302 "max-average-unrolled-insns",
280 "The maximum number of instructions to consider to unroll in a loop on average", 303 "The maximum number of instructions to consider to unroll in a loop on average.",
281 80, 0, 0) 304 80, 0, 0)
282 /* The maximum number of unrollings of a single loop. */ 305 /* The maximum number of unrollings of a single loop. */
283 DEFPARAM(PARAM_MAX_UNROLL_TIMES, 306 DEFPARAM(PARAM_MAX_UNROLL_TIMES,
284 "max-unroll-times", 307 "max-unroll-times",
285 "The maximum number of unrollings of a single loop", 308 "The maximum number of unrollings of a single loop.",
286 8, 0, 0) 309 8, 0, 0)
287 /* The maximum number of insns of a peeled loop. */ 310 /* The maximum number of insns of a peeled loop. */
288 DEFPARAM(PARAM_MAX_PEELED_INSNS, 311 DEFPARAM(PARAM_MAX_PEELED_INSNS,
289 "max-peeled-insns", 312 "max-peeled-insns",
290 "The maximum number of insns of a peeled loop", 313 "The maximum number of insns of a peeled loop.",
291 400, 0, 0) 314 100, 0, 0)
292 /* The maximum number of peelings of a single loop. */ 315 /* The maximum number of peelings of a single loop. */
293 DEFPARAM(PARAM_MAX_PEEL_TIMES, 316 DEFPARAM(PARAM_MAX_PEEL_TIMES,
294 "max-peel-times", 317 "max-peel-times",
295 "The maximum number of peelings of a single loop", 318 "The maximum number of peelings of a single loop.",
296 16, 0, 0) 319 16, 0, 0)
320 /* The maximum number of peelings of a single loop that is peeled completely. */
321 DEFPARAM(PARAM_MAX_PEEL_BRANCHES,
322 "max-peel-branches",
323 "The maximum number of branches on the path through the peeled sequence.",
324 32, 0, 0)
297 /* The maximum number of insns of a peeled loop. */ 325 /* The maximum number of insns of a peeled loop. */
298 DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS, 326 DEFPARAM(PARAM_MAX_COMPLETELY_PEELED_INSNS,
299 "max-completely-peeled-insns", 327 "max-completely-peeled-insns",
300 "The maximum number of insns of a completely peeled loop", 328 "The maximum number of insns of a completely peeled loop.",
301 400, 0, 0) 329 200, 0, 0)
302 /* The maximum number of peelings of a single loop that is peeled completely. */ 330 /* The maximum number of peelings of a single loop that is peeled completely. */
303 DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES, 331 DEFPARAM(PARAM_MAX_COMPLETELY_PEEL_TIMES,
304 "max-completely-peel-times", 332 "max-completely-peel-times",
305 "The maximum number of peelings of a single loop that is peeled completely", 333 "The maximum number of peelings of a single loop that is peeled completely.",
306 16, 0, 0) 334 16, 0, 0)
307 /* The maximum number of insns of a peeled loop that rolls only once. */ 335 /* The maximum number of insns of a peeled loop that rolls only once. */
308 DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS, 336 DEFPARAM(PARAM_MAX_ONCE_PEELED_INSNS,
309 "max-once-peeled-insns", 337 "max-once-peeled-insns",
310 "The maximum number of insns of a peeled loop that rolls only once", 338 "The maximum number of insns of a peeled loop that rolls only once.",
311 400, 0, 0) 339 400, 0, 0)
312 /* The maximum depth of a loop nest we completely peel. */ 340 /* The maximum depth of a loop nest we completely peel. */
313 DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS, 341 DEFPARAM(PARAM_MAX_UNROLL_ITERATIONS,
314 "max-completely-peel-loop-nest-depth", 342 "max-completely-peel-loop-nest-depth",
315 "The maximum depth of a loop nest we completely peel", 343 "The maximum depth of a loop nest we completely peel.",
316 8, 0, 0) 344 8, 0, 0)
317 345
318 /* The maximum number of insns of an unswitched loop. */ 346 /* The maximum number of insns of an unswitched loop. */
319 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS, 347 DEFPARAM(PARAM_MAX_UNSWITCH_INSNS,
320 "max-unswitch-insns", 348 "max-unswitch-insns",
321 "The maximum number of insns of an unswitched loop", 349 "The maximum number of insns of an unswitched loop.",
322 50, 0, 0) 350 50, 0, 0)
323 /* The maximum level of recursion in unswitch_single_loop. */ 351 /* The maximum level of recursion in unswitch_single_loop. */
324 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL, 352 DEFPARAM(PARAM_MAX_UNSWITCH_LEVEL,
325 "max-unswitch-level", 353 "max-unswitch-level",
326 "The maximum number of unswitchings in a single loop", 354 "The maximum number of unswitchings in a single loop.",
327 3, 0, 0) 355 3, 0, 0)
356
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)
328 363
329 /* The maximum number of iterations of a loop the brute force algorithm 364 /* The maximum number of iterations of a loop the brute force algorithm
330 for analysis of # of iterations of the loop tries to evaluate. */ 365 for analysis of # of iterations of the loop tries to evaluate. */
331 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK, 366 DEFPARAM(PARAM_MAX_ITERATIONS_TO_TRACK,
332 "max-iterations-to-track", 367 "max-iterations-to-track",
333 "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates", 368 "Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates.",
334 1000, 0, 0) 369 1000, 0, 0)
335 /* A cutoff to avoid costly computations of the number of iterations in 370 /* A cutoff to avoid costly computations of the number of iterations in
336 the doloop transformation. */ 371 the doloop transformation. */
337 DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST, 372 DEFPARAM(PARAM_MAX_ITERATIONS_COMPUTATION_COST,
338 "max-iterations-computation-cost", 373 "max-iterations-computation-cost",
339 "Bound on the cost of an expression to compute the number of iterations", 374 "Bound on the cost of an expression to compute the number of iterations.",
340 10, 0, 0) 375 10, 0, 0)
341 376
342 /* This parameter is used to tune SMS MAX II calculations. */ 377 /* This parameter is used to tune SMS MAX II calculations. */
343 DEFPARAM(PARAM_SMS_MAX_II_FACTOR, 378 DEFPARAM(PARAM_SMS_MAX_II_FACTOR,
344 "sms-max-ii-factor", 379 "sms-max-ii-factor",
345 "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop", 380 "A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop.",
346 100, 0, 0) 381 100, 0, 0)
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)
347 DEFPARAM(PARAM_SMS_DFA_HISTORY, 387 DEFPARAM(PARAM_SMS_DFA_HISTORY,
348 "sms-dfa-history", 388 "sms-dfa-history",
349 "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA", 389 "The number of cycles the swing modulo scheduler considers when checking conflicts using DFA.",
350 0, 0, 0) 390 0, 0, 0)
351 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD, 391 DEFPARAM(PARAM_SMS_LOOP_AVERAGE_COUNT_THRESHOLD,
352 "sms-loop-average-count-threshold", 392 "sms-loop-average-count-threshold",
353 "A threshold on the average loop count considered by the swing modulo scheduler", 393 "A threshold on the average loop count considered by the swing modulo scheduler.",
354 0, 0, 0) 394 0, 0, 0)
355 395
356 DEFPARAM(HOT_BB_COUNT_FRACTION, 396 DEFPARAM(HOT_BB_COUNT_WS_PERMILLE,
357 "hot-bb-count-fraction", 397 "hot-bb-count-ws-permille",
358 "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot", 398 "A basic block profile count is considered hot if it contributes to "
359 10000, 0, 0) 399 "the given permillage of the entire profiled execution.",
400 999, 0, 1000)
360 DEFPARAM(HOT_BB_FREQUENCY_FRACTION, 401 DEFPARAM(HOT_BB_FREQUENCY_FRACTION,
361 "hot-bb-frequency-fraction", 402 "hot-bb-frequency-fraction",
362 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot", 403 "Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot.",
363 1000, 0, 0) 404 1000, 0, 0)
405
406 DEFPARAM(UNLIKELY_BB_COUNT_FRACTION,
407 "unlikely-bb-count-fraction",
408 "The minimum fraction of profile runs a given basic block execution count must be not to be considered unlikely.",
409 20, 1, 10000)
364 410
365 DEFPARAM (PARAM_ALIGN_THRESHOLD, 411 DEFPARAM (PARAM_ALIGN_THRESHOLD,
366 "align-threshold", 412 "align-threshold",
367 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment", 413 "Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment.",
368 100, 0, 0) 414 100, 1, 0)
369 415
370 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS, 416 DEFPARAM (PARAM_ALIGN_LOOP_ITERATIONS,
371 "align-loop-iterations", 417 "align-loop-iterations",
372 "Loops iterating at least selected number of iterations will get loop alignement.", 418 "Loops iterating at least selected number of iterations will get loop alignment..",
373 4, 0, 0) 419 4, 0, 0)
374 420
375 /* For guessed profiles, the loops having unknown number of iterations 421 /* For guessed profiles, the loops having unknown number of iterations
376 are predicted to iterate relatively few (10) times at average. 422 are predicted to iterate relatively few (10) times at average.
377 For functions containing one loop with large known number of iterations 423 For functions containing one loop with large known number of iterations
378 and other loops having unbounded loops we would end up predicting all 424 and other loops having unbounded loops we would end up predicting all
379 the other loops cold that is not usually the case. So we need to artificially 425 the other loops cold that is not usually the case. So we need to artificially
380 flatten the profile. 426 flatten the profile.
381 427
382 We need to cut the maximal predicted iterations to large enough iterations 428 We need to cut the maximal predicted iterations to large enough iterations
383 so the loop appears important, but safely within HOT_BB_COUNT_FRACTION 429 so the loop appears important, but safely within maximum hotness
384 range. */ 430 range. */
385 431
386 DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS, 432 DEFPARAM(PARAM_MAX_PREDICTED_ITERATIONS,
387 "max-predicted-iterations", 433 "max-predicted-iterations",
388 "The maximum number of loop iterations we predict statically", 434 "The maximum number of loop iterations we predict statically.",
389 100, 0, 0) 435 100, 0, 0)
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)
440 in some real world programs:
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)
390 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK, 449 DEFPARAM(TRACER_DYNAMIC_COVERAGE_FEEDBACK,
391 "tracer-dynamic-coverage-feedback", 450 "tracer-dynamic-coverage-feedback",
392 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available", 451 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available.",
393 95, 0, 100) 452 95, 0, 100)
394 DEFPARAM(TRACER_DYNAMIC_COVERAGE, 453 DEFPARAM(TRACER_DYNAMIC_COVERAGE,
395 "tracer-dynamic-coverage", 454 "tracer-dynamic-coverage",
396 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available", 455 "The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available.",
397 75, 0, 100) 456 75, 0, 100)
398 DEFPARAM(TRACER_MAX_CODE_GROWTH, 457 DEFPARAM(TRACER_MAX_CODE_GROWTH,
399 "tracer-max-code-growth", 458 "tracer-max-code-growth",
400 "Maximal code growth caused by tail duplication (in percent)", 459 "Maximal code growth caused by tail duplication (in percent).",
401 100, 0, 0) 460 100, 0, 0)
402 DEFPARAM(TRACER_MIN_BRANCH_RATIO, 461 DEFPARAM(TRACER_MIN_BRANCH_RATIO,
403 "tracer-min-branch-ratio", 462 "tracer-min-branch-ratio",
404 "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)", 463 "Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent).",
405 10, 0, 100) 464 10, 0, 100)
406 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK, 465 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK,
407 "tracer-min-branch-probability-feedback", 466 "tracer-min-branch-probability-feedback",
408 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available", 467 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available.",
409 80, 0, 100) 468 80, 0, 100)
410 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY, 469 DEFPARAM(TRACER_MIN_BRANCH_PROBABILITY,
411 "tracer-min-branch-probability", 470 "tracer-min-branch-probability",
412 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available", 471 "Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available.",
413 50, 0, 100) 472 50, 0, 100)
414 473
415 /* The maximum number of incoming edges to consider for crossjumping. */ 474 /* The maximum number of incoming edges to consider for crossjumping. */
416 DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES, 475 DEFPARAM(PARAM_MAX_CROSSJUMP_EDGES,
417 "max-crossjump-edges", 476 "max-crossjump-edges",
418 "The maximum number of incoming edges to consider for crossjumping", 477 "The maximum number of incoming edges to consider for crossjumping.",
419 100, 0, 0) 478 100, 0, 0)
420 479
421 /* The minimum number of matching instructions to consider for crossjumping. */ 480 /* The minimum number of matching instructions to consider for crossjumping. */
422 DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS, 481 DEFPARAM(PARAM_MIN_CROSSJUMP_INSNS,
423 "min-crossjump-insns", 482 "min-crossjump-insns",
424 "The minimum number of matching instructions to consider for crossjumping", 483 "The minimum number of matching instructions to consider for crossjumping.",
425 5, 0, 0) 484 5, 1, 0)
426 485
427 /* The maximum number expansion factor when copying basic blocks. */ 486 /* The maximum number expansion factor when copying basic blocks. */
428 DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS, 487 DEFPARAM(PARAM_MAX_GROW_COPY_BB_INSNS,
429 "max-grow-copy-bb-insns", 488 "max-grow-copy-bb-insns",
430 "The maximum expansion factor when copying basic blocks", 489 "The maximum expansion factor when copying basic blocks.",
431 8, 0, 0) 490 8, 0, 0)
432 491
433 /* The maximum number of insns to duplicate when unfactoring computed gotos. */ 492 /* The maximum number of insns to duplicate when unfactoring computed gotos. */
434 DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS, 493 DEFPARAM(PARAM_MAX_GOTO_DUPLICATION_INSNS,
435 "max-goto-duplication-insns", 494 "max-goto-duplication-insns",
436 "The maximum number of insns to duplicate when unfactoring computed gotos", 495 "The maximum number of insns to duplicate when unfactoring computed gotos.",
437 8, 0, 0) 496 8, 0, 0)
438 497
439 /* The maximum length of path considered in cse. */ 498 /* The maximum length of path considered in cse. */
440 DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH, 499 DEFPARAM(PARAM_MAX_CSE_PATH_LENGTH,
441 "max-cse-path-length", 500 "max-cse-path-length",
442 "The maximum length of path considered in cse", 501 "The maximum length of path considered in cse.",
443 10, 0, 0) 502 10, 1, 0)
444 DEFPARAM(PARAM_MAX_CSE_INSNS, 503 DEFPARAM(PARAM_MAX_CSE_INSNS,
445 "max-cse-insns", 504 "max-cse-insns",
446 "The maximum instructions CSE process before flushing", 505 "The maximum instructions CSE process before flushing.",
447 1000, 0, 0) 506 1000, 0, 0)
448 507
449 /* The cost of expression in loop invariant motion that is considered 508 /* The cost of expression in loop invariant motion that is considered
450 expensive. */ 509 expensive. */
451 DEFPARAM(PARAM_LIM_EXPENSIVE, 510 DEFPARAM(PARAM_LIM_EXPENSIVE,
452 "lim-expensive", 511 "lim-expensive",
453 "The minimum cost of an expensive expression in the loop invariant motion", 512 "The minimum cost of an expensive expression in the loop invariant motion.",
454 20, 0, 0) 513 20, 0, 0)
455 514
456 /* Bound on number of candidates for induction variables below that 515 /* Bound on number of candidates for induction variables below that
457 all candidates are considered for each use in induction variable 516 all candidates are considered for each use in induction variable
458 optimizations. */ 517 optimizations. */
459 518
460 DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND, 519 DEFPARAM(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND,
461 "iv-consider-all-candidates-bound", 520 "iv-consider-all-candidates-bound",
462 "Bound on number of candidates below that all candidates are considered in iv optimizations", 521 "Bound on number of candidates below that all candidates are considered in iv optimizations.",
463 30, 0, 0) 522 40, 0, 0)
464 523
465 /* The induction variable optimizations give up on loops that contain more 524 /* The induction variable optimizations give up on loops that contain more
466 induction variable uses. */ 525 induction variable uses. */
467 526
468 DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES, 527 DEFPARAM(PARAM_IV_MAX_CONSIDERED_USES,
469 "iv-max-considered-uses", 528 "iv-max-considered-uses",
470 "Bound on number of iv uses in loop optimized in iv optimizations", 529 "Bound on number of iv uses in loop optimized in iv optimizations.",
471 250, 0, 0) 530 250, 0, 0)
472 531
473 /* If there are at most this number of ivs in the set, try removing unnecessary 532 /* If there are at most this number of ivs in the set, try removing unnecessary
474 ivs from the set always. */ 533 ivs from the set always. */
475 534
476 DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, 535 DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND,
477 "iv-always-prune-cand-set-bound", 536 "iv-always-prune-cand-set-bound",
478 "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization", 537 "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization.",
479 10, 0, 0) 538 10, 0, 0)
539
540 DEFPARAM(PARAM_AVG_LOOP_NITER,
541 "avg-loop-niter",
542 "Average number of iterations of a loop.",
543 10, 1, 0)
544
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)
480 549
481 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, 550 DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE,
482 "scev-max-expr-size", 551 "scev-max-expr-size",
483 "Bound on size of expressions used in the scalar evolutions analyzer", 552 "Bound on size of expressions used in the scalar evolutions analyzer.",
484 100, 0, 0) 553 100, 0, 0)
485 554
486 DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY, 555 DEFPARAM(PARAM_SCEV_MAX_EXPR_COMPLEXITY,
487 "scev-max-expr-complexity", 556 "scev-max-expr-complexity",
488 "Bound on the complexity of the expressions in the scalar evolutions analyzer", 557 "Bound on the complexity of the expressions in the scalar evolutions analyzer.",
489 10, 0, 0) 558 10, 0, 0)
490 559
491 DEFPARAM(PARAM_OMEGA_MAX_VARS, 560 DEFPARAM (PARAM_MAX_TREE_IF_CONVERSION_PHI_ARGS,
492 "omega-max-vars", 561 "max-tree-if-conversion-phi-args",
493 "Bound on the number of variables in Omega constraint systems", 562 "Maximum number of arguments in a PHI supported by TREE if-conversion "
494 128, 0, 0) 563 "unless the loop is marked with simd pragma.",
495 564 4, 2, 0)
496 DEFPARAM(PARAM_OMEGA_MAX_GEQS,
497 "omega-max-geqs",
498 "Bound on the number of inequalities in Omega constraint systems",
499 256, 0, 0)
500
501 DEFPARAM(PARAM_OMEGA_MAX_EQS,
502 "omega-max-eqs",
503 "Bound on the number of equalities in Omega constraint systems",
504 128, 0, 0)
505
506 DEFPARAM(PARAM_OMEGA_MAX_WILD_CARDS,
507 "omega-max-wild-cards",
508 "Bound on the number of wild cards in Omega constraint systems",
509 18, 0, 0)
510
511 DEFPARAM(PARAM_OMEGA_HASH_TABLE_SIZE,
512 "omega-hash-table-size",
513 "Bound on the size of the hash table in Omega constraint systems",
514 550, 0, 0)
515
516 DEFPARAM(PARAM_OMEGA_MAX_KEYS,
517 "omega-max-keys",
518 "Bound on the number of keys in Omega constraint systems",
519 500, 0, 0)
520
521 DEFPARAM(PARAM_OMEGA_ELIMINATE_REDUNDANT_CONSTRAINTS,
522 "omega-eliminate-redundant-constraints",
523 "When set to 1, use expensive methods to eliminate all redundant constraints",
524 0, 0, 1)
525 565
526 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS, 566 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIGNMENT_CHECKS,
527 "vect-max-version-for-alignment-checks", 567 "vect-max-version-for-alignment-checks",
528 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check", 568 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check.",
529 6, 0, 0) 569 6, 0, 0)
530 570
531 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, 571 DEFPARAM(PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS,
532 "vect-max-version-for-alias-checks", 572 "vect-max-version-for-alias-checks",
533 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check", 573 "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check.",
534 10, 0, 0) 574 10, 0, 0)
575
576 DEFPARAM(PARAM_VECT_MAX_PEELING_FOR_ALIGNMENT,
577 "vect-max-peeling-for-alignment",
578 "Maximum number of loop peels to enhance alignment of data references in a loop.",
579 -1, -1, 64)
535 580
536 DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS, 581 DEFPARAM(PARAM_MAX_CSELIB_MEMORY_LOCATIONS,
537 "max-cselib-memory-locations", 582 "max-cselib-memory-locations",
538 "The maximum memory locations recorded by cselib", 583 "The maximum memory locations recorded by cselib.",
539 500, 0, 0) 584 500, 0, 0)
540 585
541 #ifdef ENABLE_GC_ALWAYS_COLLECT 586 #ifdef ENABLE_GC_ALWAYS_COLLECT
542 # define GGC_MIN_EXPAND_DEFAULT 0 587 # define GGC_MIN_EXPAND_DEFAULT 0
543 # define GGC_MIN_HEAPSIZE_DEFAULT 0 588 # define GGC_MIN_HEAPSIZE_DEFAULT 0
546 # define GGC_MIN_HEAPSIZE_DEFAULT 4096 591 # define GGC_MIN_HEAPSIZE_DEFAULT 4096
547 #endif 592 #endif
548 593
549 DEFPARAM(GGC_MIN_EXPAND, 594 DEFPARAM(GGC_MIN_EXPAND,
550 "ggc-min-expand", 595 "ggc-min-expand",
551 "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap", 596 "Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap.",
552 GGC_MIN_EXPAND_DEFAULT, 0, 0) 597 GGC_MIN_EXPAND_DEFAULT, 0, 0)
553 598
554 DEFPARAM(GGC_MIN_HEAPSIZE, 599 DEFPARAM(GGC_MIN_HEAPSIZE,
555 "ggc-min-heapsize", 600 "ggc-min-heapsize",
556 "Minimum heap size before we start collecting garbage, in kilobytes", 601 "Minimum heap size before we start collecting garbage, in kilobytes.",
557 GGC_MIN_HEAPSIZE_DEFAULT, 0, 0) 602 GGC_MIN_HEAPSIZE_DEFAULT, 0, 0)
558 603
559 #undef GGC_MIN_EXPAND_DEFAULT 604 #undef GGC_MIN_EXPAND_DEFAULT
560 #undef GGC_MIN_HEAPSIZE_DEFAULT 605 #undef GGC_MIN_HEAPSIZE_DEFAULT
561 606
562 DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS, 607 DEFPARAM(PARAM_MAX_RELOAD_SEARCH_INSNS,
563 "max-reload-search-insns", 608 "max-reload-search-insns",
564 "The maximum number of instructions to search backward when looking for equivalent reload", 609 "The maximum number of instructions to search backward when looking for equivalent reload.",
565 100, 0, 0) 610 100, 0, 0)
611
612 DEFPARAM(PARAM_SINK_FREQUENCY_THRESHOLD,
613 "sink-frequency-threshold",
614 "Target block's relative execution frequency (as a percentage) required to sink a statement.",
615 75, 0, 100)
566 616
567 DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS, 617 DEFPARAM(PARAM_MAX_SCHED_REGION_BLOCKS,
568 "max-sched-region-blocks", 618 "max-sched-region-blocks",
569 "The maximum number of blocks in a region to be considered for interblock scheduling", 619 "The maximum number of blocks in a region to be considered for interblock scheduling.",
570 10, 0, 0) 620 10, 0, 0)
571 621
572 DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS, 622 DEFPARAM(PARAM_MAX_SCHED_REGION_INSNS,
573 "max-sched-region-insns", 623 "max-sched-region-insns",
574 "The maximum number of insns in a region to be considered for interblock scheduling", 624 "The maximum number of insns in a region to be considered for interblock scheduling.",
575 100, 0, 0) 625 100, 0, 0)
576 626
577 DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS, 627 DEFPARAM(PARAM_MAX_PIPELINE_REGION_BLOCKS,
578 "max-pipeline-region-blocks", 628 "max-pipeline-region-blocks",
579 "The maximum number of blocks in a region to be considered for interblock scheduling", 629 "The maximum number of blocks in a region to be considered for interblock scheduling.",
580 15, 0, 0) 630 15, 0, 0)
581 631
582 DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS, 632 DEFPARAM(PARAM_MAX_PIPELINE_REGION_INSNS,
583 "max-pipeline-region-insns", 633 "max-pipeline-region-insns",
584 "The maximum number of insns in a region to be considered for interblock scheduling", 634 "The maximum number of insns in a region to be considered for interblock scheduling.",
585 200, 0, 0) 635 200, 0, 0)
586 636
587 DEFPARAM(PARAM_MIN_SPEC_PROB, 637 DEFPARAM(PARAM_MIN_SPEC_PROB,
588 "min-spec-prob", 638 "min-spec-prob",
589 "The minimum probability of reaching a source block for interblock speculative scheduling", 639 "The minimum probability of reaching a source block for interblock speculative scheduling.",
590 40, 0, 0) 640 40, 0, 0)
591 641
592 DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS, 642 DEFPARAM(PARAM_MAX_SCHED_EXTEND_REGIONS_ITERS,
593 "max-sched-extend-regions-iters", 643 "max-sched-extend-regions-iters",
594 "The maximum number of iterations through CFG to extend regions", 644 "The maximum number of iterations through CFG to extend regions.",
595 0, 0, 0) 645 0, 0, 0)
596 646
597 DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY, 647 DEFPARAM(PARAM_MAX_SCHED_INSN_CONFLICT_DELAY,
598 "max-sched-insn-conflict-delay", 648 "max-sched-insn-conflict-delay",
599 "The maximum conflict delay for an insn to be considered for speculative motion", 649 "The maximum conflict delay for an insn to be considered for speculative motion.",
600 3, 1, 10) 650 3, 1, 10)
601 651
602 DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF, 652 DEFPARAM(PARAM_SCHED_SPEC_PROB_CUTOFF,
603 "sched-spec-prob-cutoff", 653 "sched-spec-prob-cutoff",
604 "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.", 654 "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.",
605 40, 0, 100) 655 40, 0, 100)
606 656
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
607 DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD, 662 DEFPARAM(PARAM_SELSCHED_MAX_LOOKAHEAD,
608 "selsched-max-lookahead", 663 "selsched-max-lookahead",
609 "The maximum size of the lookahead window of selective scheduling", 664 "The maximum size of the lookahead window of selective scheduling.",
610 50, 0, 0) 665 50, 0, 0)
611 666
612 DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES, 667 DEFPARAM(PARAM_SELSCHED_MAX_SCHED_TIMES,
613 "selsched-max-sched-times", 668 "selsched-max-sched-times",
614 "Maximum number of times that an insn could be scheduled", 669 "Maximum number of times that an insn could be scheduled.",
615 2, 0, 0) 670 2, 1, 0)
616 671
617 DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME, 672 DEFPARAM(PARAM_SELSCHED_INSNS_TO_RENAME,
618 "selsched-insns-to-rename", 673 "selsched-insns-to-rename",
619 "Maximum number of instructions in the ready list that are considered eligible for renaming", 674 "Maximum number of instructions in the ready list that are considered eligible for renaming.",
620 2, 0, 0) 675 2, 0, 0)
621 676
622 DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST, 677 DEFPARAM (PARAM_SCHED_MEM_TRUE_DEP_COST,
623 "sched-mem-true-dep-cost", 678 "sched-mem-true-dep-cost",
624 "Minimal distance between possibly conflicting store and load", 679 "Minimal distance between possibly conflicting store and load.",
625 1, 0, 0) 680 1, 0, 0)
681
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)
626 686
627 DEFPARAM(PARAM_MAX_LAST_VALUE_RTL, 687 DEFPARAM(PARAM_MAX_LAST_VALUE_RTL,
628 "max-last-value-rtl", 688 "max-last-value-rtl",
629 "The maximum number of RTL nodes that can be recorded as combiner's last value", 689 "The maximum number of RTL nodes that can be recorded as combiner's last value.",
630 10000, 0, 0) 690 10000, 0, 0)
691
692 DEFPARAM(PARAM_MAX_COMBINE_INSNS,
693 "max-combine-insns",
694 "The maximum number of insns combine tries to combine.",
695 4, 2, 4)
631 696
632 /* INTEGER_CST nodes are shared for values [{-1,0} .. N) for 697 /* INTEGER_CST nodes are shared for values [{-1,0} .. N) for
633 {signed,unsigned} integral types. This determines N. 698 {signed,unsigned} integral types. This determines N.
634 Experimentation shows 256 to be a good value. */ 699 Experimentation shows 251 to be a good value that generates the
700 least amount of garbage for allocating the TREE_VEC storage. */
635 DEFPARAM (PARAM_INTEGER_SHARE_LIMIT, 701 DEFPARAM (PARAM_INTEGER_SHARE_LIMIT,
636 "integer-share-limit", 702 "integer-share-limit",
637 "The upper bound for sharing integer constants", 703 "The upper bound for sharing integer constants.",
638 256, 2, 2) 704 251, 2, 2)
639
640 /* Incremental SSA updates for virtual operands may be very slow if
641 there is a large number of mappings to process. In those cases, it
642 is faster to rewrite the virtual symbols from scratch as if they
643 had been recently introduced. This heuristic cannot be applied to
644 SSA mappings for real SSA names, only symbols kept in FUD chains.
645
646 PARAM_MIN_VIRTUAL_MAPPINGS specifies the minimum number of virtual
647 mappings that should be registered to trigger the heuristic.
648
649 PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO specifies the ratio between
650 mappings and symbols. If the number of virtual mappings is
651 PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO bigger than the number of
652 virtual symbols to be updated, then the updater switches to a full
653 update for those symbols. */
654 DEFPARAM (PARAM_MIN_VIRTUAL_MAPPINGS,
655 "min-virtual-mappings",
656 "Minimum number of virtual mappings to consider switching to full virtual renames",
657 100, 0, 0)
658
659 DEFPARAM (PARAM_VIRTUAL_MAPPINGS_TO_SYMS_RATIO,
660 "virtual-mappings-ratio",
661 "Ratio between virtual mappings and virtual symbols to do full virtual renames",
662 3, 0, 0)
663 705
664 DEFPARAM (PARAM_SSP_BUFFER_SIZE, 706 DEFPARAM (PARAM_SSP_BUFFER_SIZE,
665 "ssp-buffer-size", 707 "ssp-buffer-size",
666 "The lower bound for a buffer to be considered for stack smashing protection", 708 "The lower bound for a buffer to be considered for stack smashing protection.",
667 8, 1, 0) 709 8, 1, 0)
710
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 "
714 "when not optimizing.",
715 32, 0, 0)
668 716
669 /* When we thread through a block we have to make copies of the 717 /* When we thread through a block we have to make copies of the
670 statements within the block. Clearly for large blocks the code 718 statements within the block. Clearly for large blocks the code
671 duplication is bad. 719 duplication is bad.
672 720
679 statements. So we can get the benefits of jump threading 727 statements. So we can get the benefits of jump threading
680 without excessive code bloat for pathological cases with the 728 without excessive code bloat for pathological cases with the
681 throttle set at 15 statements. */ 729 throttle set at 15 statements. */
682 DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS, 730 DEFPARAM (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS,
683 "max-jump-thread-duplication-stmts", 731 "max-jump-thread-duplication-stmts",
684 "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps", 732 "Maximum number of statements allowed in a block that needs to be duplicated when threading jumps.",
685 15, 0, 0) 733 15, 0, 0)
686 734
687 /* This is the maximum number of fields a variable may have before the pointer analysis machinery 735 /* This is the maximum number of fields a variable may have before the pointer analysis machinery
688 will stop trying to treat it in a field-sensitive manner. 736 will stop trying to treat it in a field-sensitive manner.
689 There are programs out there with thousands of fields per structure, and handling them 737 There are programs out there with thousands of fields per structure, and handling them
690 field-sensitively is not worth the cost. */ 738 field-sensitively is not worth the cost. */
691 DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE, 739 DEFPARAM (PARAM_MAX_FIELDS_FOR_FIELD_SENSITIVE,
692 "max-fields-for-field-sensitive", 740 "max-fields-for-field-sensitive",
693 "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable", 741 "Maximum number of fields in a structure before pointer analysis treats the structure as a single variable.",
694 0, 0, 0) 742 0, 0, 0)
695 743
696 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS, 744 DEFPARAM(PARAM_MAX_SCHED_READY_INSNS,
697 "max-sched-ready-insns", 745 "max-sched-ready-insns",
698 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass", 746 "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass.",
699 100, 0, 0) 747 100, 0, 0)
748
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",
752 "Maximum number of active local stores in RTL dead store elimination.",
753 5000, 0, 0)
700 754
701 /* Prefetching and cache-optimizations related parameters. Default values are 755 /* Prefetching and cache-optimizations related parameters. Default values are
702 usually set by machine description. */ 756 usually set by machine description. */
703 757
704 /* The number of insns executed before prefetch is completed. */ 758 /* The number of insns executed before prefetch is completed. */
705 759
706 DEFPARAM (PARAM_PREFETCH_LATENCY, 760 DEFPARAM (PARAM_PREFETCH_LATENCY,
707 "prefetch-latency", 761 "prefetch-latency",
708 "The number of insns executed before prefetch is completed", 762 "The number of insns executed before prefetch is completed.",
709 200, 0, 0) 763 200, 0, 0)
710 764
711 /* The number of prefetches that can run at the same time. */ 765 /* The number of prefetches that can run at the same time. */
712 766
713 DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES, 767 DEFPARAM (PARAM_SIMULTANEOUS_PREFETCHES,
714 "simultaneous-prefetches", 768 "simultaneous-prefetches",
715 "The number of prefetches that can run at the same time", 769 "The number of prefetches that can run at the same time.",
716 3, 0, 0) 770 3, 0, 0)
717 771
718 /* The size of L1 cache in kB. */ 772 /* The size of L1 cache in kB. */
719 773
720 DEFPARAM (PARAM_L1_CACHE_SIZE, 774 DEFPARAM (PARAM_L1_CACHE_SIZE,
721 "l1-cache-size", 775 "l1-cache-size",
722 "The size of L1 cache", 776 "The size of L1 cache.",
723 64, 0, 0) 777 64, 0, 0)
724 778
725 /* The size of L1 cache line in bytes. */ 779 /* The size of L1 cache line in bytes. */
726 780
727 DEFPARAM (PARAM_L1_CACHE_LINE_SIZE, 781 DEFPARAM (PARAM_L1_CACHE_LINE_SIZE,
728 "l1-cache-line-size", 782 "l1-cache-line-size",
729 "The size of L1 cache line", 783 "The size of L1 cache line.",
730 32, 0, 0) 784 32, 0, 0)
731 785
732 /* The size of L2 cache in kB. */ 786 /* The size of L2 cache in kB. */
733 787
734 DEFPARAM (PARAM_L2_CACHE_SIZE, 788 DEFPARAM (PARAM_L2_CACHE_SIZE,
735 "l2-cache-size", 789 "l2-cache-size",
736 "The size of L2 cache", 790 "The size of L2 cache.",
737 512, 0, 0) 791 512, 0, 0)
738 792
739 /* Whether we should use canonical types rather than deep "structural" 793 /* Whether we should use canonical types rather than deep "structural"
740 type checking. Setting this value to 1 (the default) improves 794 type checking. Setting this value to 1 (the default) improves
741 compilation performance in the C++ and Objective-C++ front end; 795 compilation performance in the C++ and Objective-C++ front end;
742 this value should only be set to zero to work around bugs in the 796 this value should only be set to zero to work around bugs in the
743 canonical type system by disabling it. */ 797 canonical type system by disabling it. */
744 798
745 DEFPARAM (PARAM_USE_CANONICAL_TYPES, 799 DEFPARAM (PARAM_USE_CANONICAL_TYPES,
746 "use-canonical-types", 800 "use-canonical-types",
747 "Whether to use canonical types", 801 "Whether to use canonical types.",
748 1, 0, 1) 802 1, 0, 1)
749 803
750 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH, 804 DEFPARAM (PARAM_MAX_PARTIAL_ANTIC_LENGTH,
751 "max-partial-antic-length", 805 "max-partial-antic-length",
752 "Maximum length of partial antic set when performing tree pre optimization", 806 "Maximum length of partial antic set when performing tree pre optimization.",
753 100, 0, 0) 807 100, 0, 0)
754 808
755 /* The following is used as a stop-gap limit for cases where really huge 809 /* The following is used as a stop-gap limit for cases where really huge
756 SCCs blow up memory and compile-time use too much. If we hit this limit, 810 SCCs blow up memory and compile-time use too much. If we hit this limit,
757 SCCVN and such FRE and PRE will be not done at all for the current 811 SCCVN and such FRE and PRE will be not done at all for the current
758 function. */ 812 function. */
759 813
760 DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE, 814 DEFPARAM (PARAM_SCCVN_MAX_SCC_SIZE,
761 "sccvn-max-scc-size", 815 "sccvn-max-scc-size",
762 "Maximum size of a SCC before SCCVN stops processing a function", 816 "Maximum size of a SCC before SCCVN stops processing a function.",
763 10000, 10, 0) 817 10000, 10, 0)
818
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",
827 "Maximum number of disambiguations to perform per memory access.",
828 1000, 0, 0)
764 829
765 DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM, 830 DEFPARAM (PARAM_IRA_MAX_LOOPS_NUM,
766 "ira-max-loops-num", 831 "ira-max-loops-num",
767 "Max loops number for regional RA", 832 "Max loops number for regional RA.",
768 100, 0, 0) 833 100, 0, 0)
769 834
770 DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE, 835 DEFPARAM (PARAM_IRA_MAX_CONFLICT_TABLE_SIZE,
771 "ira-max-conflict-table-size", 836 "ira-max-conflict-table-size",
772 "Max size of conflict table in MB", 837 "Max size of conflict table in MB.",
773 1000, 0, 0) 838 1000, 0, 0)
774 839
775 DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS, 840 DEFPARAM (PARAM_IRA_LOOP_RESERVED_REGS,
776 "ira-loop-reserved-regs", 841 "ira-loop-reserved-regs",
777 "The number of registers in each class kept unused by loop invariant motion", 842 "The number of registers in each class kept unused by loop invariant motion.",
778 2, 0, 0) 843 2, 0, 0)
844
845 DEFPARAM (PARAM_LRA_MAX_CONSIDERED_RELOAD_PSEUDOS,
846 "lra-max-considered-reload-pseudos",
847 "The max number of reload pseudos which are considered during spilling a non-reload pseudo.",
848 500, 0, 0)
849
850 DEFPARAM (PARAM_LRA_INHERITANCE_EBB_PROBABILITY_CUTOFF,
851 "lra-inheritance-ebb-probability-cutoff",
852 "Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA.",
853 40, 0, 100)
779 854
780 /* Switch initialization conversion will refuse to create arrays that are 855 /* Switch initialization conversion will refuse to create arrays that are
781 bigger than this parameter times the number of switch branches. */ 856 bigger than this parameter times the number of switch branches. */
782 857
783 DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO, 858 DEFPARAM (PARAM_SWITCH_CONVERSION_BRANCH_RATIO,
784 "switch-conversion-max-branch-ratio", 859 "switch-conversion-max-branch-ratio",
785 "The maximum ratio between array size and switch branches for " 860 "The maximum ratio between array size and switch branches for "
786 "a switch conversion to take place", 861 "a switch conversion to take place.",
787 8, 1, 0) 862 8, 1, 0)
788 863
789 /* Size of tiles when doing loop blocking. */ 864 /* Size of tiles when doing loop blocking. */
790 865
791 DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE, 866 DEFPARAM (PARAM_LOOP_BLOCK_TILE_SIZE,
792 "loop-block-tile-size", 867 "loop-block-tile-size",
793 "size of tiles for loop blocking", 868 "size of tiles for loop blocking.",
794 51, 0, 0) 869 51, 0, 0)
795 870
796 /* Maximal number of parameters that we allow in a SCoP. */ 871 /* Maximal number of parameters that we allow in a SCoP. */
797 872
798 DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS, 873 DEFPARAM (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS,
799 "graphite-max-nb-scop-params", 874 "graphite-max-nb-scop-params",
800 "maximum number of parameters in a SCoP", 875 "maximum number of parameters in a SCoP.",
801 10, 0, 0) 876 10, 0, 0)
802 877
803 /* Maximal number of basic blocks in the functions analyzed by Graphite. */ 878 /* Maximal number of array references in a scop. */
804 879
805 DEFPARAM (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION, 880 DEFPARAM (PARAM_GRAPHITE_MAX_ARRAYS_PER_SCOP,
806 "graphite-max-bbs-per-function", 881 "graphite-max-arrays-per-scop",
807 "maximum number of basic blocks per function to be analyzed by Graphite", 882 "maximum number of arrays per scop.",
808 100, 0, 0) 883 100, 0, 0)
884
885 DEFPARAM (PARAM_MAX_ISL_OPERATIONS,
886 "max-isl-operations",
887 "maximum number of isl operations, 0 means unlimited",
888 350000, 0, 0)
889
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
896 /* Avoid data dependence analysis on very large loops. */
897 DEFPARAM (PARAM_LOOP_MAX_DATAREFS_FOR_DATADEPS,
898 "loop-max-datarefs-for-datadeps",
899 "Maximum number of datarefs in loop for building loop data dependencies.",
900 1000, 0, 0)
809 901
810 /* Avoid doing loop invariant motion on very large loops. */ 902 /* Avoid doing loop invariant motion on very large loops. */
811 903
812 DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP, 904 DEFPARAM (PARAM_LOOP_INVARIANT_MAX_BBS_IN_LOOP,
813 "loop-invariant-max-bbs-in-loop", 905 "loop-invariant-max-bbs-in-loop",
814 "Max basic blocks number in loop for loop invariant motion", 906 "Max basic blocks number in loop for loop invariant motion.",
815 10000, 0, 0) 907 10000, 0, 0)
908
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",
914 "use internal function id in profile lookup.",
915 0, 0, 1)
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",
922 "track topn target addresses in indirect-call profile.",
923 0, 0, 1)
816 924
817 /* Avoid SLP vectorization of large basic blocks. */ 925 /* Avoid SLP vectorization of large basic blocks. */
818 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB, 926 DEFPARAM (PARAM_SLP_MAX_INSNS_IN_BB,
819 "slp-max-insns-in-bb", 927 "slp-max-insns-in-bb",
820 "Maximum number of instructions in basic block to be considered for SLP vectorization", 928 "Maximum number of instructions in basic block to be considered for SLP vectorization.",
821 1000, 0, 0) 929 1000, 0, 0)
822 930
823 DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO, 931 DEFPARAM (PARAM_MIN_INSN_TO_PREFETCH_RATIO,
824 "min-insn-to-prefetch-ratio", 932 "min-insn-to-prefetch-ratio",
825 "Min. ratio of insns to prefetches to enable prefetching for " 933 "Min. ratio of insns to prefetches to enable prefetching for "
826 "a loop with an unknown trip count", 934 "a loop with an unknown trip count.",
827 10, 0, 0) 935 9, 0, 0)
828 936
829 DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO, 937 DEFPARAM (PARAM_PREFETCH_MIN_INSN_TO_MEM_RATIO,
830 "prefetch-min-insn-to-mem-ratio", 938 "prefetch-min-insn-to-mem-ratio",
831 "Min. ratio of insns to mem ops to enable prefetching in a loop", 939 "Min. ratio of insns to mem ops to enable prefetching in a loop.",
832 3, 0, 0) 940 3, 0, 0)
833 941
834 /* Set maximum hash table size for var tracking. */ 942 /* Set maximum hash table size for var tracking. */
835 943
836 DEFPARAM (PARAM_MAX_VARTRACK_SIZE, 944 DEFPARAM (PARAM_MAX_VARTRACK_SIZE,
837 "max-vartrack-size", 945 "max-vartrack-size",
838 "Max. size of var tracking hash tables", 946 "Max. size of var tracking hash tables.",
839 50000000, 0, 0) 947 50000000, 0, 0)
948
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",
954 "Max. recursion depth for expanding var tracking expressions.",
955 12, 0, 0)
956
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",
962 "Max. size of loc list for which reverse ops should be added.",
963 50, 0, 0)
840 964
841 /* Set minimum insn uid for non-debug insns. */ 965 /* Set minimum insn uid for non-debug insns. */
842 966
843 DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID, 967 DEFPARAM (PARAM_MIN_NONDEBUG_INSN_UID,
844 "min-nondebug-insn-uid", 968 "min-nondebug-insn-uid",
845 "The minimum UID to be used for a nondebug insn", 969 "The minimum UID to be used for a nondebug insn.",
846 0, 1, 0) 970 0, 0, 0)
847 971
848 DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR, 972 DEFPARAM (PARAM_IPA_SRA_PTR_GROWTH_FACTOR,
849 "ipa-sra-ptr-growth-factor", 973 "ipa-sra-ptr-growth-factor",
850 "Maximum allowed growth of size of new parameters ipa-sra replaces " 974 "Maximum allowed growth of size of new parameters ipa-sra replaces "
851 "a pointer to an aggregate with", 975 "a pointer to an aggregate with.",
852 2, 0, 0) 976 2, 0, 0)
853 977
854 DEFPARAM (PARAM_DEVIRT_TYPE_LIST_SIZE, 978 DEFPARAM (PARAM_TM_MAX_AGGREGATE_SIZE,
855 "devirt-type-list-size", 979 "tm-max-aggregate-size",
856 "Maximum size of a type list associated with each parameter for " 980 "Size in bytes after which thread-local aggregates should be "
857 "devirtualization", 981 "instrumented with the logging functions instead of save/restore "
982 "pairs.",
983 9, 0, 0)
984
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 "
988 "considered for scalarization when compiling for speed.",
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 "
994 "considered for scalarization when compiling for size.",
995 0, 0, 0)
996
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 "
1000 "interprocedural constant propagation.",
858 8, 0, 0) 1001 8, 0, 0)
1002
1003 DEFPARAM (PARAM_IPA_CP_EVAL_THRESHOLD,
1004 "ipa-cp-eval-threshold",
1005 "Threshold ipa-cp opportunity evaluation that is still considered "
1006 "beneficial to clone..",
1007 500, 0, 0)
1008
1009 DEFPARAM (PARAM_IPA_CP_RECURSION_PENALTY,
1010 "ipa-cp-recursion-penalty",
1011 "Percentage penalty the recursive functions will receive when they "
1012 "are evaluated for cloning..",
1013 40, 0, 100)
1014
1015 DEFPARAM (PARAM_IPA_CP_SINGLE_CALL_PENALTY,
1016 "ipa-cp-single-call-penalty",
1017 "Percentage penalty functions containing a single call to another "
1018 "function will receive when they are evaluated for cloning..",
1019 15, 0, 100)
1020
1021 DEFPARAM (PARAM_IPA_MAX_AGG_ITEMS,
1022 "ipa-max-agg-items",
1023 "Maximum number of aggregate content items for a parameter in "
1024 "jump functions and lattices.",
1025 16, 0, 0)
1026
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 "
1030 "bounds or strides known..",
1031 64, 0, 0)
1032
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 "
1036 "index known..",
1037 48, 0, 0)
1038
1039 DEFPARAM (PARAM_IPA_MAX_AA_STEPS,
1040 "ipa-max-aa-steps",
1041 "Maximum number of statements that will be visited by IPA formal "
1042 "parameter analysis based on alias analysis in any given function.",
1043 25000, 0, 0)
859 1044
860 /* WHOPR partitioning configuration. */ 1045 /* WHOPR partitioning configuration. */
861 1046
862 DEFPARAM (PARAM_LTO_PARTITIONS, 1047 DEFPARAM (PARAM_LTO_PARTITIONS,
863 "lto-partitions", 1048 "lto-partitions",
864 "Number of paritions program should be split to", 1049 "Number of partitions the program should be split to.",
865 32, 0, 0) 1050 32, 1, 0)
866 1051
867 DEFPARAM (MIN_PARTITION_SIZE, 1052 DEFPARAM (MIN_PARTITION_SIZE,
868 "lto-min-partition", 1053 "lto-min-partition",
869 "Size of minimal paritition for WHOPR (in estimated instructions)", 1054 "Minimal size of a partition for LTO (in estimated instructions).",
870 1000, 0, 0) 1055 10000, 0, 0)
1056
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)
871 1061
872 /* Diagnostic parameters. */ 1062 /* Diagnostic parameters. */
873 1063
874 DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP, 1064 DEFPARAM (CXX_MAX_NAMESPACES_FOR_DIAGNOSTIC_HELP,
875 "cxx-max-namespaces-for-diagnostic-help", 1065 "cxx-max-namespaces-for-diagnostic-help",
876 "Maximum number of namespaces to search for alternatives when " 1066 "Maximum number of namespaces to search for alternatives when "
877 "name lookup fails", 1067 "name lookup fails.",
878 1000, 0, 0) 1068 1000, 0, 0)
879 1069
1070 /* Maximum number of conditional store pairs that can be sunk. */
1071 DEFPARAM (PARAM_MAX_STORES_TO_SINK,
1072 "max-stores-to-sink",
1073 "Maximum number of conditional store pairs that can be sunk.",
1074 2, 0, 0)
1075
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, "
1083 "if 0, use the default for the machine.",
1084 0, 0, 0)
1085
1086 /* Data race flags for C++0x memory model compliance. */
1087 DEFPARAM (PARAM_ALLOW_STORE_DATA_RACES,
1088 "allow-store-data-races",
1089 "Allow new data races on stores to be introduced.",
1090 0, 0, 1)
1091
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 "
1096 "reassociated tree. If 0, use the target dependent heuristic..",
1097 0, 0, 0)
1098
1099 DEFPARAM (PARAM_MAX_TAIL_MERGE_COMPARISONS,
1100 "max-tail-merge-comparisons",
1101 "Maximum amount of similar bbs to compare a bb with.",
1102 10, 0, 0)
1103
1104 DEFPARAM (PARAM_STORE_MERGING_ALLOW_UNALIGNED,
1105 "store-merging-allow-unaligned",
1106 "Allow the store merging pass to introduce unaligned stores "
1107 "if it is legal to do so.",
1108 1, 0, 1)
1109
1110 DEFPARAM (PARAM_MAX_STORES_TO_MERGE,
1111 "max-stores-to-merge",
1112 "Maximum number of constant stores to merge in the "
1113 "store merging pass.",
1114 64, 2, 0)
1115
1116 DEFPARAM (PARAM_MAX_TAIL_MERGE_ITERATIONS,
1117 "max-tail-merge-iterations",
1118 "Maximum amount of iterations of the pass over a function.",
1119 2, 0, 0)
1120
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 "
1126 "track string lengths.",
1127 10000, 0, 0)
1128
1129 /* Keep this in sync with the sched_pressure_algorithm enum. */
1130 DEFPARAM (PARAM_SCHED_PRESSURE_ALGORITHM,
1131 "sched-pressure-algorithm",
1132 "Which -fsched-pressure algorithm to apply.",
1133 1, 1, 2)
1134
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 "
1139 "strength reduction.",
1140 50, 1, 999999)
1141
1142 DEFPARAM (PARAM_ASAN_STACK,
1143 "asan-stack",
1144 "Enable asan stack protection.",
1145 1, 0, 1)
1146
1147 DEFPARAM (PARAM_ASAN_PROTECT_ALLOCAS,
1148 "asan-instrument-allocas",
1149 "Enable asan allocas/VLAs protection.",
1150 1, 0, 1)
1151
1152 DEFPARAM (PARAM_ASAN_GLOBALS,
1153 "asan-globals",
1154 "Enable asan globals protection.",
1155 1, 0, 1)
1156
1157 DEFPARAM (PARAM_ASAN_INSTRUMENT_WRITES,
1158 "asan-instrument-writes",
1159 "Enable asan store operations protection.",
1160 1, 0, 1)
1161
1162 DEFPARAM (PARAM_ASAN_INSTRUMENT_READS,
1163 "asan-instrument-reads",
1164 "Enable asan load operations protection.",
1165 1, 0, 1)
1166
1167 DEFPARAM (PARAM_ASAN_MEMINTRIN,
1168 "asan-memintrin",
1169 "Enable asan builtin functions protection.",
1170 1, 0, 1)
1171
1172 DEFPARAM (PARAM_ASAN_USE_AFTER_RETURN,
1173 "asan-use-after-return",
1174 "Enable asan detection of use-after-return bugs.",
1175 1, 0, 1)
1176
1177 DEFPARAM (PARAM_ASAN_INSTRUMENTATION_WITH_CALL_THRESHOLD,
1178 "asan-instrumentation-with-call-threshold",
1179 "Use callbacks instead of inline code if number of accesses "
1180 "in function becomes greater or equal to this number.",
1181 7000, 0, INT_MAX)
1182
1183 DEFPARAM (PARAM_USE_AFTER_SCOPE_DIRECT_EMISSION_THRESHOLD,
1184 "use-after-scope-direct-emission-threshold",
1185 "Use direct poisoning/unpoisoning instructions for variables "
1186 "smaller or equal to this number.",
1187 256, 0, INT_MAX)
1188
1189 DEFPARAM (PARAM_UNINIT_CONTROL_DEP_ATTEMPTS,
1190 "uninit-control-dep-attempts",
1191 "Maximum number of nested calls to search for control dependencies "
1192 "during uninitialized variable analysis.",
1193 1000, 1, 0)
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 "
1198 "constructor generated by Pointer Bounds Checker.",
1199 5000, 100, 0)
1200
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
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
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
1216 DEFPARAM (PARAM_MAX_FSM_THREAD_PATH_INSNS,
1217 "max-fsm-thread-path-insns",
1218 "Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path.",
1219 100, 1, 999999)
1220
1221 DEFPARAM (PARAM_MAX_FSM_THREAD_LENGTH,
1222 "max-fsm-thread-length",
1223 "Maximum number of basic blocks on a finite state automaton jump thread path.",
1224 10, 1, 999999)
1225
1226 DEFPARAM (PARAM_MAX_FSM_THREAD_PATHS,
1227 "max-fsm-thread-paths",
1228 "Maximum number of new jump thread paths to create for a finite state automaton.",
1229 50, 1, 999999)
1230
1231 DEFPARAM (PARAM_PARLOOPS_CHUNK_SIZE,
1232 "parloops-chunk-size",
1233 "Chunk size of omp schedule for loops parallelized by parloops.",
1234 0, 0, 0)
1235
1236 DEFPARAMENUM5 (PARAM_PARLOOPS_SCHEDULE,
1237 "parloops-schedule",
1238 "Schedule type of omp schedule for loops parallelized by "
1239 "parloops (static, dynamic, guided, auto, runtime).",
1240 static,
1241 static, dynamic, guided, auto, runtime)
1242
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"
1246 " SSA name.",
1247 3, 1, 10)
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)
1254
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
1269 DEFPARAM (PARAM_HSA_GEN_DEBUG_STORES,
1270 "hsa-gen-debug-stores",
1271 "Level of hsa debug stores verbosity",
1272 0, 0, 1)
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
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
1285 DEFPARAM (PARAM_VECT_EPILOGUES_NOMASK,
1286 "vect-epilogues-nomask",
1287 "Enable loop epilogue vectorization using smaller vector size.",
1288 0, 0, 1)
1289
880 /* 1290 /*
1291
881 Local variables: 1292 Local variables:
882 mode:c 1293 mode:c
883 End: 1294 End:
884 */ 1295 */