Mercurial > hg > CbC > CbC_gcc
comparison gcc/params.opt @ 145:1830386684a0
gcc-9.2.0
| author | anatofuz |
|---|---|
| date | Thu, 13 Feb 2020 11:34:05 +0900 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 131:84e7813d76e9 | 145:1830386684a0 |
|---|---|
| 1 ; Parameter options of the compiler. | |
| 2 | |
| 3 ; Copyright (C) 2019-2020 Free Software Foundation, Inc. | |
| 4 ; | |
| 5 ; This file is part of GCC. | |
| 6 ; | |
| 7 ; GCC is free software; you can redistribute it and/or modify it under | |
| 8 ; the terms of the GNU General Public License as published by the Free | |
| 9 ; Software Foundation; either version 3, or (at your option) any later | |
| 10 ; version. | |
| 11 ; | |
| 12 ; GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 ; WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 ; FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 ; for more details. | |
| 16 ; | |
| 17 ; You should have received a copy of the GNU General Public License | |
| 18 ; along with GCC; see the file COPYING3. If not see | |
| 19 ; <http://www.gnu.org/licenses/>. | |
| 20 | |
| 21 ; See the GCC internals manual (options.texi) for a description of this file's format. | |
| 22 | |
| 23 ; Please try to keep this file in ASCII collating order. | |
| 24 | |
| 25 -param=align-loop-iterations= | |
| 26 Common Joined UInteger Var(param_align_loop_iterations) Init(4) Param Optimization | |
| 27 Loops iterating at least selected number of iterations will get loop alignment. | |
| 28 | |
| 29 -param=align-threshold= | |
| 30 Common Joined UInteger Var(param_align_threshold) Init(100) IntegerRange(1, 65536) Param Optimization | |
| 31 Select fraction of the maximal frequency of executions of basic block in function given basic block get alignment. | |
| 32 | |
| 33 -param=asan-globals= | |
| 34 Common Joined UInteger Var(param_asan_globals) Init(1) IntegerRange(0, 1) Param | |
| 35 Enable asan globals protection. | |
| 36 | |
| 37 -param=asan-instrument-allocas= | |
| 38 Common Joined UInteger Var(param_asan_protect_allocas) Init(1) IntegerRange(0, 1) Param Optimization | |
| 39 Enable asan allocas/VLAs protection. | |
| 40 | |
| 41 -param=asan-instrument-reads= | |
| 42 Common Joined UInteger Var(param_asan_instrument_reads) Init(1) IntegerRange(0, 1) Param Optimization | |
| 43 Enable asan load operations protection. | |
| 44 | |
| 45 -param=asan-instrument-writes= | |
| 46 Common Joined UInteger Var(param_asan_instrument_writes) Init(1) IntegerRange(0, 1) Param Optimization | |
| 47 Enable asan store operations protection. | |
| 48 | |
| 49 -param=asan-instrumentation-with-call-threshold= | |
| 50 Common Joined UInteger Var(param_asan_instrumentation_with_call_threshold) Init(7000) Param Optimization | |
| 51 Use callbacks instead of inline code if number of accesses in function becomes greater or equal to this number. | |
| 52 | |
| 53 -param=asan-memintrin= | |
| 54 Common Joined UInteger Var(param_asan_memintrin) Init(1) IntegerRange(0, 1) Param Optimization | |
| 55 Enable asan builtin functions protection. | |
| 56 | |
| 57 -param=asan-stack= | |
| 58 Common Joined UInteger Var(param_asan_stack) Init(1) IntegerRange(0, 1) Param Optimization | |
| 59 Enable asan stack protection. | |
| 60 | |
| 61 -param=asan-use-after-return= | |
| 62 Common Joined UInteger Var(param_asan_use_after_return) Init(1) IntegerRange(0, 1) Param Optimization | |
| 63 Enable asan detection of use-after-return bugs. | |
| 64 | |
| 65 -param=avg-loop-niter= | |
| 66 Common Joined UInteger Var(param_avg_loop_niter) Init(10) IntegerRange(1, 65536) Param Optimization | |
| 67 Average number of iterations of a loop. | |
| 68 | |
| 69 -param=avoid-fma-max-bits= | |
| 70 Common Joined UInteger Var(param_avoid_fma_max_bits) IntegerRange(0, 512) Param Optimization | |
| 71 Maximum number of bits for which we avoid creating FMAs. | |
| 72 | |
| 73 -param=builtin-expect-probability= | |
| 74 Common Joined UInteger Var(param_builtin_expect_probability) Init(90) IntegerRange(0, 100) Param Optimization | |
| 75 Set the estimated probability in percentage for builtin expect. The default value is 90% probability. | |
| 76 | |
| 77 -param=builtin-string-cmp-inline-length= | |
| 78 Common Joined UInteger Var(param_builtin_string_cmp_inline_length) Init(3) IntegerRange(0, 100) Param Optimization | |
| 79 The maximum length of a constant string for a builtin string cmp call eligible for inlining. The default value is 3. | |
| 80 | |
| 81 -param=case-values-threshold= | |
| 82 Common Joined UInteger Var(param_case_values_threshold) Param Optimization | |
| 83 The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine. | |
| 84 | |
| 85 -param=comdat-sharing-probability= | |
| 86 Common Joined UInteger Var(param_comdat_sharing_probability) Init(20) Param Optimization | |
| 87 Probability that COMDAT function will be shared with different compilation unit. | |
| 88 | |
| 89 -param=cxx-max-namespaces-for-diagnostic-help= | |
| 90 Common Joined UInteger Var(param_cxx_max_namespaces_for_diagnostic_help) Init(1000) Param | |
| 91 Maximum number of namespaces to search for alternatives when name lookup fails. | |
| 92 | |
| 93 -param=dse-max-alias-queries-per-store= | |
| 94 Common Joined UInteger Var(param_dse_max_alias_queries_per_store) Init(256) Param Optimization | |
| 95 Maximum number of queries into the alias oracle per store. | |
| 96 | |
| 97 -param=dse-max-object-size= | |
| 98 Common Joined UInteger Var(param_dse_max_object_size) Init(256) Param Optimization | |
| 99 Maximum size (in bytes) of objects tracked bytewise by dead store elimination. | |
| 100 | |
| 101 -param=early-inlining-insns= | |
| 102 Common Joined UInteger Var(param_early_inlining_insns) Init(6) Optimization Param | |
| 103 Maximal estimated growth of function body caused by early inlining of single call. | |
| 104 | |
| 105 -param=fsm-maximum-phi-arguments= | |
| 106 Common Joined UInteger Var(param_fsm_maximum_phi_arguments) Init(100) IntegerRange(1, 999999) Param Optimization | |
| 107 Maximum number of arguments a PHI may have before the FSM threader will not try to thread through its block. | |
| 108 | |
| 109 -param=fsm-scale-path-blocks= | |
| 110 Common Joined UInteger Var(param_fsm_scale_path_blocks) Init(3) IntegerRange(1, 10) Param Optimization | |
| 111 Scale factor to apply to the number of blocks in a threading path when comparing to the number of (scaled) statements. | |
| 112 | |
| 113 -param=fsm-scale-path-stmts= | |
| 114 Common Joined UInteger Var(param_fsm_scale_path_stmts) Init(2) IntegerRange(1, 10) Param Optimization | |
| 115 Scale factor to apply to the number of statements in a threading path when comparing to the number of (scaled) blocks. | |
| 116 | |
| 117 -param=gcse-after-reload-critical-fraction= | |
| 118 Common Joined UInteger Var(param_gcse_after_reload_critical_fraction) Init(10) Param Optimization | |
| 119 The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload. | |
| 120 | |
| 121 -param=gcse-after-reload-partial-fraction= | |
| 122 Common Joined UInteger Var(param_gcse_after_reload_partial_fraction) Init(3) Param Optimization | |
| 123 The threshold ratio for performing partial redundancy elimination after reload. | |
| 124 | |
| 125 -param=gcse-cost-distance-ratio= | |
| 126 Common Joined UInteger Var(param_gcse_cost_distance_ratio) Init(10) Param Optimization | |
| 127 Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations. | |
| 128 | |
| 129 -param=gcse-unrestricted-cost= | |
| 130 Common Joined UInteger Var(param_gcse_unrestricted_cost) Init(3) Param Optimization | |
| 131 Cost at which GCSE optimizations will not constraint the distance an expression can travel. | |
| 132 | |
| 133 -param=ggc-min-expand= | |
| 134 Common Joined UInteger Var(param_ggc_min_expand) Init(30) Param | |
| 135 Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap. | |
| 136 | |
| 137 -param=ggc-min-heapsize= | |
| 138 Common Joined UInteger Var(param_ggc_min_heapsize) Init(4096) Param | |
| 139 Minimum heap size before we start collecting garbage, in kilobytes. | |
| 140 | |
| 141 -param=gimple-fe-computed-hot-bb-threshold= | |
| 142 Common Joined UInteger Var(param_gimple_fe_computed_hot_bb_threshold) Param | |
| 143 The number of executions of a basic block which is considered hot. The parameter is used only in GIMPLE FE. | |
| 144 | |
| 145 -param=graphite-allow-codegen-errors= | |
| 146 Common Joined UInteger Var(param_graphite_allow_codegen_errors) IntegerRange(0, 1) Param | |
| 147 Whether codegen errors should be ICEs when -fchecking. | |
| 148 | |
| 149 -param=graphite-max-arrays-per-scop= | |
| 150 Common Joined UInteger Var(param_graphite_max_arrays_per_scop) Init(100) Param Optimization | |
| 151 Maximum number of arrays per SCoP. | |
| 152 | |
| 153 -param=graphite-max-nb-scop-params= | |
| 154 Common Joined UInteger Var(param_graphite_max_nb_scop_params) Init(10) Param Optimization | |
| 155 Maximum number of parameters in a SCoP. | |
| 156 | |
| 157 -param=hash-table-verification-limit= | |
| 158 Common Joined UInteger Var(param_hash_table_verification_limit) Init(10) Param | |
| 159 The number of elements for which hash table verification is done for each searched element. | |
| 160 | |
| 161 -param=hot-bb-count-fraction= | |
| 162 Common Joined UInteger Var(param_hot_bb_count_fraction) Init(10000) Param | |
| 163 The denominator n of fraction 1/n of the maximal execution count of a basic block in the entire program that a basic block needs to at least have in order to be considered hot (used in non-LTO mode). | |
| 164 | |
| 165 -param=hot-bb-count-ws-permille= | |
| 166 Common Joined UInteger Var(param_hot_bb_count_ws_permille) Init(990) IntegerRange(0, 1000) Param | |
| 167 The number of most executed permilles of the profiled execution of the entire program to which the execution count of a basic block must be part of in order to be considered hot (used in LTO mode). | |
| 168 | |
| 169 -param=hot-bb-frequency-fraction= | |
| 170 Common Joined UInteger Var(param_hot_bb_frequency_fraction) Init(1000) Param | |
| 171 The denominator n of fraction 1/n of the execution frequency of the entry block of a function that a basic block of this function needs to at least have in order to be considered hot. | |
| 172 | |
| 173 -param=hsa-gen-debug-stores= | |
| 174 Common Joined UInteger Var(param_hsa_gen_debug_stores) IntegerRange(0, 1) Param | |
| 175 Level of hsa debug stores verbosity. | |
| 176 | |
| 177 -param=inline-heuristics-hint-percent= | |
| 178 Common Joined UInteger Var(param_inline_heuristics_hint_percent) Init(200) Optimization IntegerRange(100, 1000000) Param | |
| 179 The scale (in percents) applied to inline-insns-single and auto limits when heuristics hints that inlining is very profitable. | |
| 180 | |
| 181 -param=inline-min-speedup= | |
| 182 Common Joined UInteger Var(param_inline_min_speedup) Init(30) Optimization IntegerRange(0, 100) Param | |
| 183 The minimal estimated speedup allowing inliner to ignore inline-insns-single and inline-insns-auto. | |
| 184 | |
| 185 -param=inline-unit-growth= | |
| 186 Common Joined UInteger Var(param_inline_unit_growth) Init(40) Optimization Param | |
| 187 How much can given compilation unit grow because of the inlining (in percent). | |
| 188 | |
| 189 -param=integer-share-limit= | |
| 190 Common Joined UInteger Var(param_integer_share_limit) Init(251) IntegerRange(2, 65536) Param | |
| 191 The upper bound for sharing integer constants. | |
| 192 | |
| 193 -param=ipa-cp-eval-threshold= | |
| 194 Common Joined UInteger Var(param_ipa_cp_eval_threshold) Init(500) Param Optimization | |
| 195 Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone. | |
| 196 | |
| 197 -param=ipa-cp-loop-hint-bonus= | |
| 198 Common Joined UInteger Var(param_ipa_cp_loop_hint_bonus) Init(64) Param Optimization | |
| 199 Compile-time bonus IPA-CP assigns to candidates which make loop bounds or strides known. | |
| 200 | |
| 201 -param=ipa-cp-max-recursive-depth= | |
| 202 Common Joined UInteger Var(param_ipa_cp_max_recursive_depth) Init(8) Param Optimization | |
| 203 Maximum depth of recursive cloning for self-recursive function. | |
| 204 | |
| 205 -param=ipa-cp-min-recursive-probability= | |
| 206 Common Joined UInteger Var(param_ipa_cp_min_recursive_probability) Init(2) Param Optimization | |
| 207 Recursive cloning only when the probability of call being executed exceeds the parameter. | |
| 208 | |
| 209 -param=ipa-cp-recursion-penalty= | |
| 210 Common Joined UInteger Var(param_ipa_cp_recursion_penalty) Init(40) IntegerRange(0, 100) Param Optimization | |
| 211 Percentage penalty the recursive functions will receive when they are evaluated for cloning. | |
| 212 | |
| 213 -param=ipa-cp-single-call-penalty= | |
| 214 Common Joined UInteger Var(param_ipa_cp_single_call_penalty) Init(15) IntegerRange(0, 100) Param Optimization | |
| 215 Percentage penalty functions containing a single call to another function will receive when they are evaluated for cloning. | |
| 216 | |
| 217 -param=ipa-cp-unit-growth= | |
| 218 Common Joined UInteger Var(param_ipa_cp_unit_growth) Init(10) Param Optimization | |
| 219 How much can given compilation unit grow because of the interprocedural constant propagation (in percent). | |
| 220 | |
| 221 -param=ipa-cp-value-list-size= | |
| 222 Common Joined UInteger Var(param_ipa_cp_value_list_size) Init(8) Param Optimization | |
| 223 Maximum size of a list of values associated with each parameter for interprocedural constant propagation. | |
| 224 | |
| 225 -param=ipa-max-aa-steps= | |
| 226 Common Joined UInteger Var(param_ipa_max_aa_steps) Init(25000) Param Optimization | |
| 227 Maximum number of statements that will be visited by IPA formal parameter analysis based on alias analysis in any given function. | |
| 228 | |
| 229 -param=ipa-max-agg-items= | |
| 230 Common Joined UInteger Var(param_ipa_max_agg_items) Init(16) Param Optimization | |
| 231 Maximum number of aggregate content items for a parameter in jump functions and lattices. | |
| 232 | |
| 233 -param=ipa-max-param-expr-ops= | |
| 234 Common Joined UInteger Var(param_ipa_max_param_expr_ops) Init(10) Param Optimization | |
| 235 Maximum number of operations in a parameter expression that can be handled by IPA analysis. | |
| 236 | |
| 237 -param=ipa-max-switch-predicate-bounds= | |
| 238 Common Joined UInteger Var(param_ipa_max_switch_predicate_bounds) Init(5) Param Optimization | |
| 239 Maximal number of boundary endpoints of case ranges of switch statement used during IPA functoin summary generation. | |
| 240 | |
| 241 -param=ipa-sra-max-replacements= | |
| 242 Common Joined UInteger Var(param_ipa_sra_max_replacements) Optimization Init(8) IntegerRange(0, 16) Param | |
| 243 Maximum pieces that IPA-SRA tracks per formal parameter, as a consequence, also the maximum number of replacements of a formal parameter. | |
| 244 | |
| 245 -param=ipa-sra-ptr-growth-factor= | |
| 246 Common Joined UInteger Var(param_ipa_sra_ptr_growth_factor) Init(2) Param Optimization | |
| 247 Maximum allowed growth of number and total size of new parameters that ipa-sra replaces a pointer to an aggregate with. | |
| 248 | |
| 249 -param=ira-loop-reserved-regs= | |
| 250 Common Joined UInteger Var(param_ira_loop_reserved_regs) Init(2) Param Optimization | |
| 251 The number of registers in each class kept unused by loop invariant motion. | |
| 252 | |
| 253 -param=ira-max-conflict-table-size= | |
| 254 Common Joined UInteger Var(param_ira_max_conflict_table_size) Init(1000) Param Optimization | |
| 255 Max size of conflict table in MB. | |
| 256 | |
| 257 -param=ira-max-loops-num= | |
| 258 Common Joined UInteger Var(param_ira_max_loops_num) Init(100) Param Optimization | |
| 259 Max loops number for regional RA. | |
| 260 | |
| 261 -param=iv-always-prune-cand-set-bound= | |
| 262 Common Joined UInteger Var(param_iv_always_prune_cand_set_bound) Init(10) Param Optimization | |
| 263 If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization. | |
| 264 | |
| 265 -param=iv-consider-all-candidates-bound= | |
| 266 Common Joined UInteger Var(param_iv_consider_all_candidates_bound) Init(40) Param Optimization | |
| 267 Bound on number of candidates below that all candidates are considered in iv optimizations. | |
| 268 | |
| 269 -param=iv-max-considered-uses= | |
| 270 Common Joined UInteger Var(param_iv_max_considered_uses) Init(250) Param Optimization | |
| 271 Bound on number of iv uses in loop optimized in iv optimizations. | |
| 272 | |
| 273 -param=jump-table-max-growth-ratio-for-size= | |
| 274 Common Joined UInteger Var(param_jump_table_max_growth_ratio_for_size) Init(300) Param Optimization | |
| 275 The maximum code size growth ratio when expanding into a jump table (in percent). The parameter is used when optimizing for size. | |
| 276 | |
| 277 -param=jump-table-max-growth-ratio-for-speed= | |
| 278 Common Joined UInteger Var(param_jump_table_max_growth_ratio_for_speed) Init(800) Param Optimization | |
| 279 The maximum code size growth ratio when expanding into a jump table (in percent). The parameter is used when optimizing for speed. | |
| 280 | |
| 281 -param=l1-cache-line-size= | |
| 282 Common Joined UInteger Var(param_l1_cache_line_size) Init(32) Param Optimization | |
| 283 The size of L1 cache line. | |
| 284 | |
| 285 -param=l1-cache-size= | |
| 286 Common Joined UInteger Var(param_l1_cache_size) Init(64) Param Optimization | |
| 287 The size of L1 cache. | |
| 288 | |
| 289 -param=l2-cache-size= | |
| 290 Common Joined UInteger Var(param_l2_cache_size) Init(512) Param Optimization | |
| 291 The size of L2 cache. | |
| 292 | |
| 293 -param=large-function-growth= | |
| 294 Common Joined UInteger Var(param_large_function_growth) Optimization Init(100) Param | |
| 295 Maximal growth due to inlining of large function (in percent). | |
| 296 | |
| 297 -param=large-function-insns= | |
| 298 Common Joined UInteger Var(param_large_function_insns) Optimization Init(2700) Param | |
| 299 The size of function body to be considered large. | |
| 300 | |
| 301 -param=large-stack-frame= | |
| 302 Common Joined UInteger Var(param_large_stack_frame) Init(256) Optimization Param | |
| 303 The size of stack frame to be considered large. | |
| 304 | |
| 305 -param=large-stack-frame-growth= | |
| 306 Common Joined UInteger Var(param_stack_frame_growth) Optimization Init(1000) Param | |
| 307 Maximal stack frame growth due to inlining (in percent). | |
| 308 | |
| 309 -param=large-unit-insns= | |
| 310 Common Joined UInteger Var(param_large_unit_insns) Optimization Init(10000) Param | |
| 311 The size of translation unit to be considered large. | |
| 312 | |
| 313 -param=lim-expensive= | |
| 314 Common Joined UInteger Var(param_lim_expensive) Init(20) Param Optimization | |
| 315 The minimum cost of an expensive expression in the loop invariant motion. | |
| 316 | |
| 317 -param=logical-op-non-short-circuit= | |
| 318 Common Joined UInteger Var(param_logical_op_non_short_circuit) Init(-1) IntegerRange(-1, 1) Param | |
| 319 True if a non-short-circuit operation is optimal. | |
| 320 | |
| 321 -param=loop-block-tile-size= | |
| 322 Common Joined UInteger Var(param_loop_block_tile_size) Init(51) Param Optimization | |
| 323 Size of tiles for loop blocking. | |
| 324 | |
| 325 -param=loop-interchange-max-num-stmts= | |
| 326 Common Joined UInteger Var(param_loop_interchange_max_num_stmts) Init(64) Param Optimization | |
| 327 The maximum number of stmts in loop nest for loop interchange. | |
| 328 | |
| 329 -param=loop-interchange-stride-ratio= | |
| 330 Common Joined UInteger Var(param_loop_interchange_stride_ratio) Init(2) Param Optimization | |
| 331 The minimum stride ratio for loop interchange to be profitable. | |
| 332 | |
| 333 -param=loop-invariant-max-bbs-in-loop= | |
| 334 Common Joined UInteger Var(param_loop_invariant_max_bbs_in_loop) Init(10000) Param Optimization | |
| 335 Max basic blocks number in loop for loop invariant motion. | |
| 336 | |
| 337 -param=loop-max-datarefs-for-datadeps= | |
| 338 Common Joined UInteger Var(param_loop_max_datarefs_for_datadeps) Init(1000) Param Optimization | |
| 339 Maximum number of datarefs in loop for building loop data dependencies. | |
| 340 | |
| 341 -param=loop-versioning-max-inner-insns= | |
| 342 Common Joined UInteger Var(param_loop_versioning_max_inner_insns) Init(200) Param Optimization | |
| 343 The maximum number of instructions in an inner loop that is being considered for versioning. | |
| 344 | |
| 345 -param=loop-versioning-max-outer-insns= | |
| 346 Common Joined UInteger Var(param_loop_versioning_max_outer_insns) Init(100) Param Optimization | |
| 347 The maximum number of instructions in an outer loop that is being considered for versioning, on top of the instructions in inner loops. | |
| 348 | |
| 349 -param=lra-inheritance-ebb-probability-cutoff= | |
| 350 Common Joined UInteger Var(param_lra_inheritance_ebb_probability_cutoff) Init(40) IntegerRange(0, 100) Param Optimization | |
| 351 Minimal fall-through edge probability in percentage used to add BB to inheritance EBB in LRA. | |
| 352 | |
| 353 -param=lra-max-considered-reload-pseudos= | |
| 354 Common Joined UInteger Var(param_lra_max_considered_reload_pseudos) Init(500) Param Optimization | |
| 355 The max number of reload pseudos which are considered during spilling a non-reload pseudo. | |
| 356 | |
| 357 -param=lto-max-partition= | |
| 358 Common Joined UInteger Var(param_max_partition_size) Init(1000000) Param | |
| 359 Maximal size of a partition for LTO (in estimated instructions). | |
| 360 | |
| 361 -param=lto-max-streaming-parallelism= | |
| 362 Common Joined UInteger Var(param_max_lto_streaming_parallelism) Init(32) IntegerRange(1, 65536) Param | |
| 363 maximal number of LTO partitions streamed in parallel. | |
| 364 | |
| 365 -param=lto-min-partition= | |
| 366 Common Joined UInteger Var(param_min_partition_size) Init(10000) Param | |
| 367 Minimal size of a partition for LTO (in estimated instructions). | |
| 368 | |
| 369 -param=lto-partitions= | |
| 370 Common Joined UInteger Var(param_lto_partitions) Init(128) IntegerRange(1, 65536) Param | |
| 371 Number of partitions the program should be split to. | |
| 372 | |
| 373 -param=max-average-unrolled-insns= | |
| 374 Common Joined UInteger Var(param_max_average_unrolled_insns) Init(80) Param Optimization | |
| 375 The maximum number of instructions to consider to unroll in a loop on average. | |
| 376 | |
| 377 -param=max-combine-insns= | |
| 378 Common Joined UInteger Var(param_max_combine_insns) Init(4) IntegerRange(2, 4) Param Optimization | |
| 379 The maximum number of insns combine tries to combine. | |
| 380 | |
| 381 -param=max-completely-peel-loop-nest-depth= | |
| 382 Common Joined UInteger Var(param_max_unroll_iterations) Init(8) Param Optimization | |
| 383 The maximum depth of a loop nest we completely peel. | |
| 384 | |
| 385 -param=max-completely-peel-times= | |
| 386 Common Joined UInteger Var(param_max_completely_peel_times) Init(16) Param Optimization | |
| 387 The maximum number of peelings of a single loop that is peeled completely. | |
| 388 | |
| 389 -param=max-completely-peeled-insns= | |
| 390 Common Joined UInteger Var(param_max_completely_peeled_insns) Init(200) Param Optimization | |
| 391 The maximum number of insns of a completely peeled loop. | |
| 392 | |
| 393 -param=max-crossjump-edges= | |
| 394 Common Joined UInteger Var(param_max_crossjump_edges) Init(100) Param Optimization | |
| 395 The maximum number of incoming edges to consider for crossjumping. | |
| 396 | |
| 397 -param=max-cse-insns= | |
| 398 Common Joined UInteger Var(param_max_cse_insns) Init(1000) Param Optimization | |
| 399 The maximum instructions CSE process before flushing. | |
| 400 | |
| 401 -param=max-cse-path-length= | |
| 402 Common Joined UInteger Var(param_max_cse_path_length) Init(10) IntegerRange(1, 65536) Param Optimization | |
| 403 The maximum length of path considered in cse. | |
| 404 | |
| 405 -param=max-cselib-memory-locations= | |
| 406 Common Joined UInteger Var(param_max_cselib_memory_locations) Init(500) Param Optimization | |
| 407 The maximum memory locations recorded by cselib. | |
| 408 | |
| 409 -param=max-debug-marker-count= | |
| 410 Common Joined UInteger Var(param_max_debug_marker_count) Init(100000) Param Optimization | |
| 411 Max. count of debug markers to expand or inline. | |
| 412 | |
| 413 -param=max-delay-slot-insn-search= | |
| 414 Common Joined UInteger Var(param_max_delay_slot_insn_search) Init(100) Param Optimization | |
| 415 The maximum number of instructions to consider to fill a delay slot. | |
| 416 | |
| 417 -param=max-delay-slot-live-search= | |
| 418 Common Joined UInteger Var(param_max_delay_slot_live_search) Init(333) Param Optimization | |
| 419 The maximum number of instructions to consider to find accurate live register information. | |
| 420 | |
| 421 -param=max-dse-active-local-stores= | |
| 422 Common Joined UInteger Var(param_max_dse_active_local_stores) Init(5000) Param Optimization | |
| 423 Maximum number of active local stores in RTL dead store elimination. | |
| 424 | |
| 425 -param=max-early-inliner-iterations= | |
| 426 Common Joined UInteger Var(param_early_inliner_max_iterations) Init(1) Param Optimization | |
| 427 The maximum number of nested indirect inlining performed by early inliner. | |
| 428 | |
| 429 -param=max-fields-for-field-sensitive= | |
| 430 Common Joined UInteger Var(param_max_fields_for_field_sensitive) Param | |
| 431 Maximum number of fields in a structure before pointer analysis treats the structure as a single variable. | |
| 432 | |
| 433 -param=max-fsm-thread-length= | |
| 434 Common Joined UInteger Var(param_max_fsm_thread_length) Init(10) IntegerRange(1, 999999) Param Optimization | |
| 435 Maximum number of basic blocks on a finite state automaton jump thread path. | |
| 436 | |
| 437 -param=max-fsm-thread-path-insns= | |
| 438 Common Joined UInteger Var(param_max_fsm_thread_path_insns) Init(100) IntegerRange(1, 999999) Param Optimization | |
| 439 Maximum number of instructions to copy when duplicating blocks on a finite state automaton jump thread path. | |
| 440 | |
| 441 -param=max-fsm-thread-paths= | |
| 442 Common Joined UInteger Var(param_max_fsm_thread_paths) Init(50) IntegerRange(1, 999999) Param Optimization | |
| 443 Maximum number of new jump thread paths to create for a finite state automaton. | |
| 444 | |
| 445 -param=max-gcse-insertion-ratio= | |
| 446 Common Joined UInteger Var(param_max_gcse_insertion_ratio) Init(20) Param Optimization | |
| 447 The maximum ratio of insertions to deletions of expressions in GCSE. | |
| 448 | |
| 449 -param=max-gcse-memory= | |
| 450 Common Joined UInteger Var(param_max_gcse_memory) Init(134217728) Param Optimization | |
| 451 The maximum amount of memory to be allocated by GCSE. | |
| 452 | |
| 453 -param=max-goto-duplication-insns= | |
| 454 Common Joined UInteger Var(param_max_goto_duplication_insns) Init(8) Param Optimization | |
| 455 The maximum number of insns to duplicate when unfactoring computed gotos. | |
| 456 | |
| 457 -param=max-grow-copy-bb-insns= | |
| 458 Common Joined UInteger Var(param_max_grow_copy_bb_insns) Init(8) Param Optimization | |
| 459 The maximum expansion factor when copying basic blocks. | |
| 460 | |
| 461 -param=max-hoist-depth= | |
| 462 Common Joined UInteger Var(param_max_hoist_depth) Init(30) Param Optimization | |
| 463 Maximum depth of search in the dominator tree for expressions to hoist. | |
| 464 | |
| 465 -param=max-inline-insns-auto= | |
| 466 Common Joined UInteger Var(param_max_inline_insns_auto) Init(15) Optimization Param | |
| 467 The maximum number of instructions when automatically inlining. | |
| 468 | |
| 469 -param=max-inline-insns-recursive= | |
| 470 Common Joined UInteger Var(param_max_inline_insns_recursive) Optimization Init(450) Param | |
| 471 The maximum number of instructions inline function can grow to via recursive inlining. | |
| 472 | |
| 473 -param=max-inline-insns-recursive-auto= | |
| 474 Common Joined UInteger Var(param_max_inline_insns_recursive_auto) Optimization Init(450) Param | |
| 475 The maximum number of instructions non-inline function can grow to via recursive inlining. | |
| 476 | |
| 477 -param=max-inline-insns-single= | |
| 478 Common Joined UInteger Var(param_max_inline_insns_single) Optimization Init(70) Param | |
| 479 The maximum number of instructions in a single function eligible for inlining. | |
| 480 | |
| 481 -param=max-inline-insns-size= | |
| 482 Common Joined UInteger Var(param_max_inline_insns_size) Optimization Param | |
| 483 The maximum number of instructions when inlining for size. | |
| 484 | |
| 485 -param=max-inline-insns-small= | |
| 486 Common Joined UInteger Var(param_max_inline_insns_small) Optimization Param | |
| 487 The maximum number of instructions when automatically inlining small functions. | |
| 488 | |
| 489 -param=max-inline-recursive-depth= | |
| 490 Common Joined UInteger Var(param_max_inline_recursive_depth) Optimization Init(8) Param | |
| 491 The maximum depth of recursive inlining for inline functions. | |
| 492 | |
| 493 -param=max-inline-recursive-depth-auto= | |
| 494 Common Joined UInteger Var(param_max_inline_recursive_depth_auto) Optimization Init(8) Param | |
| 495 The maximum depth of recursive inlining for non-inline functions. | |
| 496 | |
| 497 -param=max-isl-operations= | |
| 498 Common Joined UInteger Var(param_max_isl_operations) Init(350000) Param Optimization | |
| 499 Maximum number of isl operations, 0 means unlimited. | |
| 500 | |
| 501 -param=max-iterations-computation-cost= | |
| 502 Common Joined UInteger Var(param_max_iterations_computation_cost) Init(10) Param Optimization | |
| 503 Bound on the cost of an expression to compute the number of iterations. | |
| 504 | |
| 505 -param=max-iterations-to-track= | |
| 506 Common Joined UInteger Var(param_max_iterations_to_track) Init(1000) Param Optimization | |
| 507 Bound on the number of iterations the brute force # of iterations analysis algorithm evaluates. | |
| 508 | |
| 509 -param=max-jump-thread-duplication-stmts= | |
| 510 Common Joined UInteger Var(param_max_jump_thread_duplication_stmts) Init(15) Param Optimization | |
| 511 Maximum number of statements allowed in a block that needs to be duplicated when threading jumps. | |
| 512 | |
| 513 -param=max-last-value-rtl= | |
| 514 Common Joined UInteger Var(param_max_last_value_rtl) Init(10000) Param Optimization | |
| 515 The maximum number of RTL nodes that can be recorded as combiner's last value. | |
| 516 | |
| 517 -param=max-loop-header-insns= | |
| 518 Common Joined UInteger Var(param_max_loop_header_insns) Init(20) Param Optimization | |
| 519 The maximum number of insns in loop header duplicated by the copy loop headers pass. | |
| 520 | |
| 521 -param=max-modulo-backtrack-attempts= | |
| 522 Common Joined UInteger Var(param_max_modulo_backtrack_attempts) Init(40) Param Optimization | |
| 523 The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop. | |
| 524 | |
| 525 -param=max-partial-antic-length= | |
| 526 Common Joined UInteger Var(param_max_partial_antic_length) Init(100) Param Optimization | |
| 527 Maximum length of partial antic set when performing tree pre optimization. | |
| 528 | |
| 529 -param=max-peel-branches= | |
| 530 Common Joined UInteger Var(param_max_peel_branches) Init(32) Param Optimization | |
| 531 The maximum number of branches on the path through the peeled sequence. | |
| 532 | |
| 533 -param=max-peel-times= | |
| 534 Common Joined UInteger Var(param_max_peel_times) Init(16) Param Optimization | |
| 535 The maximum number of peelings of a single loop. | |
| 536 | |
| 537 -param=max-peeled-insns= | |
| 538 Common Joined UInteger Var(param_max_peeled_insns) Init(100) Param Optimization | |
| 539 The maximum number of insns of a peeled loop. | |
| 540 | |
| 541 -param=max-pending-list-length= | |
| 542 Common Joined UInteger Var(param_max_pending_list_length) Init(32) Param Optimization | |
| 543 The maximum length of scheduling's pending operations list. | |
| 544 | |
| 545 -param=max-pipeline-region-blocks= | |
| 546 Common Joined UInteger Var(param_max_pipeline_region_blocks) Init(15) Param Optimization | |
| 547 The maximum number of blocks in a region to be considered for interblock scheduling. | |
| 548 | |
| 549 -param=max-pipeline-region-insns= | |
| 550 Common Joined UInteger Var(param_max_pipeline_region_insns) Init(200) Param Optimization | |
| 551 The maximum number of insns in a region to be considered for interblock scheduling. | |
| 552 | |
| 553 -param=max-pow-sqrt-depth= | |
| 554 Common Joined UInteger Var(param_max_pow_sqrt_depth) Init(5) IntegerRange(1, 32) Param Optimization | |
| 555 Maximum depth of sqrt chains to use when synthesizing exponentiation by a real constant. | |
| 556 | |
| 557 -param=max-predicted-iterations= | |
| 558 Common Joined UInteger Var(param_max_predicted_iterations) Init(100) IntegerRange(0, 65536) Param Optimization | |
| 559 The maximum number of loop iterations we predict statically. | |
| 560 | |
| 561 -param=max-reload-search-insns= | |
| 562 Common Joined UInteger Var(param_max_reload_search_insns) Init(100) Param Optimization | |
| 563 The maximum number of instructions to search backward when looking for equivalent reload. | |
| 564 | |
| 565 -param=max-rtl-if-conversion-insns= | |
| 566 Common Joined UInteger Var(param_max_rtl_if_conversion_insns) Init(10) IntegerRange(0, 99) Param Optimization | |
| 567 Maximum number of insns in a basic block to consider for RTL if-conversion. | |
| 568 | |
| 569 -param=max-rtl-if-conversion-predictable-cost= | |
| 570 Common Joined UInteger Var(param_max_rtl_if_conversion_predictable_cost) Init(20) IntegerRange(0, 200) Param Optimization | |
| 571 Maximum permissible cost for the sequence that would be generated by the RTL if-conversion pass for a branch that is considered predictable. | |
| 572 | |
| 573 -param=max-rtl-if-conversion-unpredictable-cost= | |
| 574 Common Joined UInteger Var(param_max_rtl_if_conversion_unpredictable_cost) Init(40) IntegerRange(0, 200) Param Optimization | |
| 575 Maximum permissible cost for the sequence that would be generated by the RTL if-conversion pass for a branch that is considered unpredictable. | |
| 576 | |
| 577 -param=max-sched-extend-regions-iters= | |
| 578 Common Joined UInteger Var(param_max_sched_extend_regions_iters) Param Optimization | |
| 579 The maximum number of iterations through CFG to extend regions. | |
| 580 | |
| 581 -param=max-sched-insn-conflict-delay= | |
| 582 Common Joined UInteger Var(param_max_sched_insn_conflict_delay) Init(3) IntegerRange(1, 10) Param Optimization | |
| 583 The maximum conflict delay for an insn to be considered for speculative motion. | |
| 584 | |
| 585 -param=max-sched-ready-insns= | |
| 586 Common Joined UInteger Var(param_max_sched_ready_insns) Init(100) IntegerRange(1, 65536) Param Optimization | |
| 587 The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass. | |
| 588 | |
| 589 -param=max-sched-region-blocks= | |
| 590 Common Joined UInteger Var(param_max_sched_region_blocks) Init(10) Param Optimization | |
| 591 The maximum number of blocks in a region to be considered for interblock scheduling. | |
| 592 | |
| 593 -param=max-sched-region-insns= | |
| 594 Common Joined UInteger Var(param_max_sched_region_insns) Init(100) Param Optimization | |
| 595 The maximum number of insns in a region to be considered for interblock scheduling. | |
| 596 | |
| 597 -param=max-slsr-cand-scan= | |
| 598 Common Joined UInteger Var(param_max_slsr_candidate_scan) Init(50) IntegerRange(1, 999999) Param Optimization | |
| 599 Maximum length of candidate scans for straight-line strength reduction. | |
| 600 | |
| 601 -param=max-speculative-devirt-maydefs= | |
| 602 Common Joined UInteger Var(param_max_speculative_devirt_maydefs) Init(50) Param Optimization | |
| 603 Maximum number of may-defs visited when devirtualizing speculatively. | |
| 604 | |
| 605 -param=max-ssa-name-query-depth= | |
| 606 Common Joined UInteger Var(param_max_ssa_name_query_depth) Init(3) IntegerRange(1, 10) Param | |
| 607 Maximum recursion depth allowed when querying a property of an SSA name. | |
| 608 | |
| 609 -param=max-stores-to-merge= | |
| 610 Common Joined UInteger Var(param_max_stores_to_merge) Init(64) IntegerRange(2, 65536) Param Optimization | |
| 611 Maximum number of constant stores to merge in the store merging pass. | |
| 612 | |
| 613 -param=max-stores-to-sink= | |
| 614 Common Joined UInteger Var(param_max_stores_to_sink) Init(2) Param Optimization | |
| 615 Maximum number of conditional store pairs that can be sunk. | |
| 616 | |
| 617 -param=max-tail-merge-comparisons= | |
| 618 Common Joined UInteger Var(param_max_tail_merge_comparisons) Init(10) Param Optimization | |
| 619 Maximum amount of similar bbs to compare a bb with. | |
| 620 | |
| 621 -param=max-tail-merge-iterations= | |
| 622 Common Joined UInteger Var(param_max_tail_merge_iterations) Init(2) Param Optimization | |
| 623 Maximum amount of iterations of the pass over a function. | |
| 624 | |
| 625 -param=max-tracked-strlens= | |
| 626 Common Joined UInteger Var(param_max_tracked_strlens) Init(10000) Param Optimization | |
| 627 Maximum number of strings for which strlen optimization pass will track string lengths. | |
| 628 | |
| 629 -param=max-tree-if-conversion-phi-args= | |
| 630 Common Joined UInteger Var(param_max_tree_if_conversion_phi_args) Init(4) IntegerRange(2, 65536) Param Optimization | |
| 631 Maximum number of arguments in a PHI supported by TREE if-conversion unless the loop is marked with simd pragma. | |
| 632 | |
| 633 -param=max-unroll-times= | |
| 634 Common Joined UInteger Var(param_max_unroll_times) Init(8) Param Optimization | |
| 635 The maximum number of unrollings of a single loop. | |
| 636 | |
| 637 -param=max-unrolled-insns= | |
| 638 Common Joined UInteger Var(param_max_unrolled_insns) Init(200) Param Optimization | |
| 639 The maximum number of instructions to consider to unroll in a loop. | |
| 640 | |
| 641 -param=max-unswitch-insns= | |
| 642 Common Joined UInteger Var(param_max_unswitch_insns) Init(50) Param Optimization | |
| 643 The maximum number of insns of an unswitched loop. | |
| 644 | |
| 645 -param=max-unswitch-level= | |
| 646 Common Joined UInteger Var(param_max_unswitch_level) Init(3) Param Optimization | |
| 647 The maximum number of unswitchings in a single loop. | |
| 648 | |
| 649 -param=max-variable-expansions-in-unroller= | |
| 650 Common Joined UInteger Var(param_max_variable_expansions) Init(1) Param Optimization | |
| 651 If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling. | |
| 652 | |
| 653 -param=max-vartrack-expr-depth= | |
| 654 Common Joined UInteger Var(param_max_vartrack_expr_depth) Init(12) Param Optimization | |
| 655 Max. recursion depth for expanding var tracking expressions. | |
| 656 | |
| 657 -param=max-vartrack-reverse-op-size= | |
| 658 Common Joined UInteger Var(param_max_vartrack_reverse_op_size) Init(50) Param Optimization | |
| 659 Max. size of loc list for which reverse ops should be added. | |
| 660 | |
| 661 -param=max-vartrack-size= | |
| 662 Common Joined UInteger Var(param_max_vartrack_size) Init(50000000) Param Optimization | |
| 663 Max. size of var tracking hash tables. | |
| 664 | |
| 665 -param=max-vrp-switch-assertions= | |
| 666 Common Joined UInteger Var(param_max_vrp_switch_assertions) Init(10) Param Optimization | |
| 667 Maximum number of assertions to add along the default edge of a switch statement during VRP. | |
| 668 | |
| 669 -param=min-crossjump-insns= | |
| 670 Common Joined UInteger Var(param_min_crossjump_insns) Init(5) IntegerRange(1, 65536) Param Optimization | |
| 671 The minimum number of matching instructions to consider for crossjumping. | |
| 672 | |
| 673 -param=min-inline-recursive-probability= | |
| 674 Common Joined UInteger Var(param_min_inline_recursive_probability) Init(10) Optimization Param | |
| 675 Inline recursively only when the probability of call being executed exceeds the parameter. | |
| 676 | |
| 677 -param=min-insn-to-prefetch-ratio= | |
| 678 Common Joined UInteger Var(param_min_insn_to_prefetch_ratio) Init(9) Param Optimization | |
| 679 Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count. | |
| 680 | |
| 681 -param=min-loop-cond-split-prob= | |
| 682 Common Joined UInteger Var(param_min_loop_cond_split_prob) Init(30) IntegerRange(0, 100) Param Optimization | |
| 683 The minimum threshold for probability of semi-invariant condition statement to trigger loop split. | |
| 684 | |
| 685 -param=min-nondebug-insn-uid= | |
| 686 Common Joined UInteger Var(param_min_nondebug_insn_uid) Param | |
| 687 The minimum UID to be used for a nondebug insn. | |
| 688 | |
| 689 -param=min-size-for-stack-sharing= | |
| 690 Common Joined UInteger Var(param_min_size_for_stack_sharing) Init(32) Param Optimization | |
| 691 The minimum size of variables taking part in stack slot sharing when not optimizing. | |
| 692 | |
| 693 -param=min-spec-prob= | |
| 694 Common Joined UInteger Var(param_min_spec_prob) Init(40) Param Optimization | |
| 695 The minimum probability of reaching a source block for interblock speculative scheduling. | |
| 696 | |
| 697 -param=min-vect-loop-bound= | |
| 698 Common Joined UInteger Var(param_min_vect_loop_bound) Param Optimization | |
| 699 If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization. | |
| 700 | |
| 701 -param=parloops-chunk-size= | |
| 702 Common Joined UInteger Var(param_parloops_chunk_size) Param Optimization | |
| 703 Chunk size of omp schedule for loops parallelized by parloops. | |
| 704 | |
| 705 -param=parloops-min-per-thread= | |
| 706 Common Joined UInteger Var(param_parloops_min_per_thread) Init(100) IntegerRange(2, 65536) Param Optimization | |
| 707 Minimum number of iterations per thread of an innermost parallelized loop. | |
| 708 | |
| 709 -param=parloops-schedule= | |
| 710 Common Joined Var(param_parloops_schedule) Enum(parloops_schedule_type) Param Optimization | |
| 711 --param=parloops-schedule=[static|dynamic|guided|auto|runtime] Schedule type of omp schedule for loops parallelized by parloops. | |
| 712 | |
| 713 Enum | |
| 714 Name(parloops_schedule_type) Type(int) | |
| 715 | |
| 716 EnumValue | |
| 717 Enum(parloops_schedule_type) String(static) Value(PARLOOPS_SCHEDULE_STATIC) | |
| 718 | |
| 719 EnumValue | |
| 720 Enum(parloops_schedule_type) String(dynamic) Value(PARLOOPS_SCHEDULE_DYNAMIC) | |
| 721 | |
| 722 EnumValue | |
| 723 Enum(parloops_schedule_type) String(guided) Value(PARLOOPS_SCHEDULE_GUIDED) | |
| 724 | |
| 725 EnumValue | |
| 726 Enum(parloops_schedule_type) String(auto) Value(PARLOOPS_SCHEDULE_AUTO) | |
| 727 | |
| 728 EnumValue | |
| 729 Enum(parloops_schedule_type) String(runtime) Value(PARLOOPS_SCHEDULE_RUNTIME) | |
| 730 | |
| 731 -param=partial-inlining-entry-probability= | |
| 732 Common Joined UInteger Var(param_partial_inlining_entry_probability) Init(70) Optimization IntegerRange(0, 100) Param | |
| 733 Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen. | |
| 734 | |
| 735 -param=predictable-branch-outcome= | |
| 736 Common Joined UInteger Var(param_predictable_branch_outcome) Init(2) IntegerRange(0, 50) Param Optimization | |
| 737 Maximal estimated outcome of branch considered predictable. | |
| 738 | |
| 739 -param=prefetch-dynamic-strides= | |
| 740 Common Joined UInteger Var(param_prefetch_dynamic_strides) Init(1) IntegerRange(0, 1) Param Optimization | |
| 741 Whether software prefetch hints should be issued for non-constant strides. | |
| 742 | |
| 743 -param=prefetch-latency= | |
| 744 Common Joined UInteger Var(param_prefetch_latency) Init(200) Param Optimization | |
| 745 The number of insns executed before prefetch is completed. | |
| 746 | |
| 747 -param=prefetch-min-insn-to-mem-ratio= | |
| 748 Common Joined UInteger Var(param_prefetch_min_insn_to_mem_ratio) Init(3) Param Optimization | |
| 749 Min. ratio of insns to mem ops to enable prefetching in a loop. | |
| 750 | |
| 751 -param=prefetch-minimum-stride= | |
| 752 Common Joined UInteger Var(param_prefetch_minimum_stride) Init(-1) Param Optimization | |
| 753 The minimum constant stride beyond which we should use prefetch hints for. | |
| 754 | |
| 755 -param=profile-func-internal-id= | |
| 756 Common Joined UInteger Var(param_profile_func_internal_id) IntegerRange(0, 1) Param | |
| 757 Use internal function id in profile lookup. | |
| 758 | |
| 759 -param=rpo-vn-max-loop-depth= | |
| 760 Common Joined UInteger Var(param_rpo_vn_max_loop_depth) Init(7) IntegerRange(2, 65536) Param Optimization | |
| 761 Maximum depth of a loop nest to fully value-number optimistically. | |
| 762 | |
| 763 -param=sccvn-max-alias-queries-per-access= | |
| 764 Common Joined UInteger Var(param_sccvn_max_alias_queries_per_access) Init(1000) Param Optimization | |
| 765 Maximum number of disambiguations to perform per memory access. | |
| 766 | |
| 767 -param=scev-max-expr-complexity= | |
| 768 Common Joined UInteger Var(param_scev_max_expr_complexity) Init(10) Param Optimization | |
| 769 Bound on the complexity of the expressions in the scalar evolutions analyzer. | |
| 770 | |
| 771 -param=scev-max-expr-size= | |
| 772 Common Joined UInteger Var(param_scev_max_expr_size) Init(100) Param Optimization | |
| 773 Bound on size of expressions used in the scalar evolutions analyzer. | |
| 774 | |
| 775 -param=sched-autopref-queue-depth= | |
| 776 Common Joined UInteger Var(param_sched_autopref_queue_depth) Init(-1) Param Optimization | |
| 777 Hardware autoprefetcher scheduler model control flag. Number of lookahead cycles the model looks into, at '0' only enable instruction sorting heuristic. Disabled by default. | |
| 778 | |
| 779 -param=sched-mem-true-dep-cost= | |
| 780 Common Joined UInteger Var(param_sched_mem_true_dep_cost) Init(1) Param Optimization | |
| 781 Minimal distance between possibly conflicting store and load. | |
| 782 | |
| 783 -param=sched-pressure-algorithm= | |
| 784 Common Joined UInteger Var(param_sched_pressure_algorithm) Init(1) IntegerRange(1, 2) Param Optimization | |
| 785 Which -fsched-pressure algorithm to apply. | |
| 786 | |
| 787 -param=sched-spec-prob-cutoff= | |
| 788 Common Joined UInteger Var(param_sched_spec_prob_cutoff) Init(40) IntegerRange(0, 100) Param Optimization | |
| 789 The minimal probability of speculation success (in percents), so that speculative insn will be scheduled. | |
| 790 | |
| 791 -param=sched-state-edge-prob-cutoff= | |
| 792 Common Joined UInteger Var(param_sched_state_edge_prob_cutoff) Init(10) IntegerRange(0, 100) Param Optimization | |
| 793 The minimum probability an edge must have for the scheduler to save its state across it. | |
| 794 | |
| 795 -param=selsched-insns-to-rename= | |
| 796 Common Joined UInteger Var(param_selsched_insns_to_rename) Init(2) Param Optimization | |
| 797 Maximum number of instructions in the ready list that are considered eligible for renaming. | |
| 798 | |
| 799 -param=selsched-max-lookahead= | |
| 800 Common Joined UInteger Var(param_selsched_max_lookahead) Init(50) Param Optimization | |
| 801 The maximum size of the lookahead window of selective scheduling. | |
| 802 | |
| 803 -param=selsched-max-sched-times= | |
| 804 Common Joined UInteger Var(param_selsched_max_sched_times) Init(2) IntegerRange(1, 65536) Param Optimization | |
| 805 Maximum number of times that an insn could be scheduled. | |
| 806 | |
| 807 -param=simultaneous-prefetches= | |
| 808 Common Joined UInteger Var(param_simultaneous_prefetches) Init(3) Param Optimization | |
| 809 The number of prefetches that can run at the same time. | |
| 810 | |
| 811 -param=sink-frequency-threshold= | |
| 812 Common Joined UInteger Var(param_sink_frequency_threshold) Init(75) IntegerRange(0, 100) Param Optimization | |
| 813 Target block's relative execution frequency (as a percentage) required to sink a statement. | |
| 814 | |
| 815 -param=slp-max-insns-in-bb= | |
| 816 Common Joined UInteger Var(param_slp_max_insns_in_bb) Init(1000) Param Optimization | |
| 817 Maximum number of instructions in basic block to be considered for SLP vectorization. | |
| 818 | |
| 819 -param=sms-dfa-history= | |
| 820 Common Joined UInteger Var(param_sms_dfa_history) IntegerRange(0, 16) Param Optimization | |
| 821 The number of cycles the swing modulo scheduler considers when checking conflicts using DFA. | |
| 822 | |
| 823 -param=sms-loop-average-count-threshold= | |
| 824 Common Joined UInteger Var(param_sms_loop_average_count_threshold) Param Optimization | |
| 825 A threshold on the average loop count considered by the swing modulo scheduler. | |
| 826 | |
| 827 -param=sms-max-ii-factor= | |
| 828 Common Joined UInteger Var(param_sms_max_ii_factor) Init(2) IntegerRange(1, 16) Param Optimization | |
| 829 A factor for tuning the upper bound that swing modulo scheduler uses for scheduling a loop. | |
| 830 | |
| 831 -param=sms-min-sc= | |
| 832 Common Joined UInteger Var(param_sms_min_sc) Init(2) IntegerRange(1, 2) Param Optimization | |
| 833 The minimum value of stage count that swing modulo scheduler will generate. | |
| 834 | |
| 835 -param=sra-max-scalarization-size-Osize= | |
| 836 Common Joined UInteger Var(param_sra_max_scalarization_size_size) Param Optimization | |
| 837 Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for size. | |
| 838 | |
| 839 -param=sra-max-scalarization-size-Ospeed= | |
| 840 Common Joined UInteger Var(param_sra_max_scalarization_size_speed) Param Optimization | |
| 841 Maximum size, in storage units, of an aggregate which should be considered for scalarization when compiling for speed. | |
| 842 | |
| 843 -param=ssa-name-def-chain-limit= | |
| 844 Common Joined UInteger Var(param_ssa_name_def_chain_limit) Init(512) Param Optimization | |
| 845 The maximum number of SSA_NAME assignments to follow in determining a value. | |
| 846 | |
| 847 -param=ssp-buffer-size= | |
| 848 Common Joined UInteger Var(param_ssp_buffer_size) Init(8) IntegerRange(1, 65536) Param Optimization | |
| 849 The lower bound for a buffer to be considered for stack smashing protection. | |
| 850 | |
| 851 -param=stack-clash-protection-guard-size= | |
| 852 Common Joined UInteger Var(param_stack_clash_protection_guard_size) Init(12) IntegerRange(12, 30) Param Optimization | |
| 853 Size of the stack guard expressed as a power of two in bytes. | |
| 854 | |
| 855 -param=stack-clash-protection-probe-interval= | |
| 856 Common Joined UInteger Var(param_stack_clash_protection_probe_interval) Init(12) IntegerRange(10, 16) Param Optimization | |
| 857 Interval in which to probe the stack expressed as a power of two in bytes. | |
| 858 | |
| 859 -param=store-merging-allow-unaligned= | |
| 860 Common Joined UInteger Var(param_store_merging_allow_unaligned) Init(1) IntegerRange(0, 1) Param Optimization | |
| 861 Allow the store merging pass to introduce unaligned stores if it is legal to do so. | |
| 862 | |
| 863 -param=store-merging-max-size= | |
| 864 Common Joined UInteger Var(param_store_merging_max_size) Init(65536) IntegerRange(1, 65536) Param Optimization | |
| 865 Maximum size of a single store merging region in bytes. | |
| 866 | |
| 867 -param=switch-conversion-max-branch-ratio= | |
| 868 Common Joined UInteger Var(param_switch_conversion_branch_ratio) Init(8) IntegerRange(1, 65536) Param Optimization | |
| 869 The maximum ratio between array size and switch branches for a switch conversion to take place. | |
| 870 | |
| 871 -param=tm-max-aggregate-size= | |
| 872 Common Joined UInteger Var(param_tm_max_aggregate_size) Init(9) Param Optimization | |
| 873 Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs. | |
| 874 | |
| 875 -param=tracer-dynamic-coverage= | |
| 876 Common Joined UInteger Var(param_tracer_dynamic_coverage) Init(75) IntegerRange(0, 100) Param Optimization | |
| 877 The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available. | |
| 878 | |
| 879 -param=tracer-dynamic-coverage-feedback= | |
| 880 Common Joined UInteger Var(param_tracer_dynamic_coverage_feedback) Init(95) IntegerRange(0, 100) Param Optimization | |
| 881 The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available. | |
| 882 | |
| 883 -param=tracer-max-code-growth= | |
| 884 Common Joined UInteger Var(param_tracer_max_code_growth) Init(100) Param Optimization | |
| 885 Maximal code growth caused by tail duplication (in percent). | |
| 886 | |
| 887 -param=tracer-min-branch-probability= | |
| 888 Common Joined UInteger Var(param_tracer_min_branch_probability) Init(50) IntegerRange(0, 100) Param Optimization | |
| 889 Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available. | |
| 890 | |
| 891 -param=tracer-min-branch-probability-feedback= | |
| 892 Common Joined UInteger Var(param_tracer_min_branch_probability_feedback) Init(80) IntegerRange(0, 100) Param Optimization | |
| 893 Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available. | |
| 894 | |
| 895 -param=tracer-min-branch-ratio= | |
| 896 Common Joined UInteger Var(param_tracer_min_branch_ratio) Init(10) IntegerRange(0, 100) Param Optimization | |
| 897 Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent). | |
| 898 | |
| 899 -param=tree-reassoc-width= | |
| 900 Common Joined UInteger Var(param_tree_reassoc_width) Param Optimization | |
| 901 Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic. | |
| 902 | |
| 903 -param=uninit-control-dep-attempts= | |
| 904 Common Joined UInteger Var(param_uninit_control_dep_attempts) Init(1000) IntegerRange(1, 65536) Param Optimization | |
| 905 Maximum number of nested calls to search for control dependencies during uninitialized variable analysis. | |
| 906 | |
| 907 -param=uninlined-function-insns= | |
| 908 Common Joined UInteger Var(param_uninlined_function_insns) Init(2) Optimization IntegerRange(0, 1000000) Param | |
| 909 Instruction accounted for function prologue, epilogue and other overhead. | |
| 910 | |
| 911 -param=uninlined-function-time= | |
| 912 Common Joined UInteger Var(param_uninlined_function_time) Optimization IntegerRange(0, 1000000) Param | |
| 913 Time accounted for function prologue, epilogue and other overhead. | |
| 914 | |
| 915 -param=uninlined-thunk-insns= | |
| 916 Common Joined UInteger Var(param_uninlined_function_thunk_insns) Optimization Init(2) IntegerRange(0, 1000000) Param | |
| 917 Instruction accounted for function thunk overhead. | |
| 918 | |
| 919 -param=uninlined-thunk-time= | |
| 920 Common Joined UInteger Var(param_uninlined_function_thunk_time) Optimization Init(2) IntegerRange(0, 1000000) Param | |
| 921 Time accounted for function thunk overhead. | |
| 922 | |
| 923 -param=unlikely-bb-count-fraction= | |
| 924 Common Joined UInteger Var(param_unlikely_bb_count_fraction) Init(20) Param Optimization | |
| 925 The denominator n of fraction 1/n of the number of profiled runs of the entire program below which the execution count of a basic block must be in order for the basic block to be considered unlikely. | |
| 926 | |
| 927 -param=unroll-jam-max-unroll= | |
| 928 Common Joined UInteger Var(param_unroll_jam_max_unroll) Init(4) Param Optimization | |
| 929 Maximum unroll factor for the unroll-and-jam transformation. | |
| 930 | |
| 931 -param=unroll-jam-min-percent= | |
| 932 Common Joined UInteger Var(param_unroll_jam_min_percent) Init(1) IntegerRange(0, 100) Param Optimization | |
| 933 Minimum percentage of memrefs that must go away for unroll-and-jam to be considered profitable. | |
| 934 | |
| 935 -param=use-after-scope-direct-emission-threshold= | |
| 936 Common Joined UInteger Var(param_use_after_scope_direct_emission_threshold) Init(256) Param Optimization | |
| 937 Use direct poisoning/unpoisoning instructions for variables smaller or equal to this number. | |
| 938 | |
| 939 -param=use-canonical-types= | |
| 940 Common Joined UInteger Var(param_use_canonical_types) Init(1) IntegerRange(0, 1) Param | |
| 941 Whether to use canonical types. | |
| 942 | |
| 943 -param=vect-epilogues-nomask= | |
| 944 Common Joined UInteger Var(param_vect_epilogues_nomask) Init(1) IntegerRange(0, 1) Param Optimization | |
| 945 Enable loop epilogue vectorization using smaller vector size. | |
| 946 | |
| 947 -param=vect-max-peeling-for-alignment= | |
| 948 Common Joined UInteger Var(param_vect_max_peeling_for_alignment) Init(-1) IntegerRange(-1, 64) Param Optimization | |
| 949 Maximum number of loop peels to enhance alignment of data references in a loop. | |
| 950 | |
| 951 -param=vect-max-version-for-alias-checks= | |
| 952 Common Joined UInteger Var(param_vect_max_version_for_alias_checks) Init(10) Param Optimization | |
| 953 Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check. | |
| 954 | |
| 955 -param=vect-max-version-for-alignment-checks= | |
| 956 Common Joined UInteger Var(param_vect_max_version_for_alignment_checks) Init(6) Param Optimization | |
| 957 Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check. | |
| 958 | |
| 959 ; This comment is to ensure we retain the blank line above. |