## Mercurial > hg > CbC > GCC_original

### comparison gcc/params.def @ 16:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision
number or hash, or revset expression.

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 */ |