| 1 | /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\ |
| 2 | |* *| |
| 3 | |* Option Parsing Definitions *| |
| 4 | |* *| |
| 5 | |* Automatically generated file, do not edit! *| |
| 6 | |* *| |
| 7 | \*===----------------------------------------------------------------------===*/ |
| 8 | |
| 9 | ///////// |
| 10 | // Tables |
| 11 | |
| 12 | #if defined(OPTTABLE_CODE) || defined(OPTIONS_STRUCT_DEFS) |
| 13 | namespace { |
| 14 | enum ID : unsigned { |
| 15 | OPT_INVALID = 0, |
| 16 | OPT_INPUT, |
| 17 | OPT_UNKNOWN, |
| 18 | OPT_disable_binop_extract_shuffle, |
| 19 | OPT_disable_loop_idiom_vectorize_all, |
| 20 | OPT_disable_loop_idiom_vectorize_bytecmp, |
| 21 | OPT_disable_loop_idiom_vectorize_find_first_byte, |
| 22 | OPT_disable_vector_combine, |
| 23 | OPT_enable_early_exit_vectorization_with_side_effects, |
| 24 | OPT_enable_early_exit_vectorization, |
| 25 | OPT_enable_epilogue_vectorization, |
| 26 | OPT_enable_histogram_loop_vectorization, |
| 27 | OPT_enable_if_conversion, |
| 28 | OPT_enable_ind_var_reg_heur, |
| 29 | OPT_enable_interleave_to_reduce_stalls, |
| 30 | OPT_enable_interleaved_mem_accesses, |
| 31 | OPT_enable_loadstore_runtime_interleave, |
| 32 | OPT_enable_masked_interleaved_mem_accesses, |
| 33 | OPT_enable_vplan_native_path, |
| 34 | OPT_epilogue_tail_folding_policy, |
| 35 | OPT_epilogue_vectorization_minimum_VF, |
| 36 | OPT_force_ordered_reductions, |
| 37 | OPT_force_partial_aliasing_vectorization, |
| 38 | OPT_force_tail_folding_style, |
| 39 | OPT_force_target_instruction_cost, |
| 40 | OPT_force_target_load_latency, |
| 41 | OPT_force_target_max_scalar_interleave, |
| 42 | OPT_force_target_max_vector_interleave, |
| 43 | OPT_force_target_num_scalar_regs, |
| 44 | OPT_force_target_num_vector_regs, |
| 45 | OPT_force_target_supports_gather_scatter_ops, |
| 46 | OPT_force_target_supports_masked_memory_ops, |
| 47 | OPT_force_target_supports_scalable_vectors, |
| 48 | OPT_force_widen_divrem_via_masked_intrinsic, |
| 49 | OPT_hints_allow_reordering, |
| 50 | OPT_interleave_loops, |
| 51 | OPT_loop_idiom_vectorize_bytecmp_vf, |
| 52 | OPT_loop_idiom_vectorize_style, |
| 53 | OPT_loop_idiom_vectorize_verify, |
| 54 | OPT_loop_vectorize_with_block_frequency, |
| 55 | OPT_low_trip_count_loop_body_size_limit, |
| 56 | OPT_lv_compressing_patterns, |
| 57 | OPT_lv_strided_pointer_ivs, |
| 58 | OPT_max_nested_scalar_reduction_interleave, |
| 59 | OPT_pragma_vectorize_scev_check_threshold, |
| 60 | OPT_prefer_inloop_reductions, |
| 61 | OPT_prefer_predicated_reduction_select, |
| 62 | OPT_sbvec_allow_files, |
| 63 | OPT_sbvec_allow_non_pow2, |
| 64 | #if !defined(NDEBUG) |
| 65 | OPT_sbvec_always_verify, |
| 66 | #endif |
| 67 | OPT_sbvec_collect_seeds, |
| 68 | OPT_sbvec_cost_threshold, |
| 69 | OPT_sbvec_max_users_to_consider, |
| 70 | OPT_sbvec_passes, |
| 71 | OPT_sbvec_print_pass_pipeline, |
| 72 | OPT_sbvec_seed_bundle_size_limit, |
| 73 | OPT_sbvec_seed_groups_limit, |
| 74 | OPT_sbvec_stop_at, |
| 75 | OPT_sbvec_stop_bndl, |
| 76 | OPT_sbvec_vec_reg_bits, |
| 77 | OPT_scalable_epilogue_vf_cost_scale_factor, |
| 78 | OPT_scalable_vectorization, |
| 79 | OPT_slp_copyable_elements, |
| 80 | OPT_slp_cost_loop_trip_count, |
| 81 | OPT_slp_disable_tree_reorder, |
| 82 | OPT_slp_enable_masked_stores, |
| 83 | OPT_slp_enable_strided_stores, |
| 84 | OPT_slp_force_strided_loads, |
| 85 | OPT_slp_inst_count_check, |
| 86 | OPT_slp_max_look_ahead_depth, |
| 87 | OPT_slp_max_reg_size, |
| 88 | OPT_slp_max_root_look_ahead_depth, |
| 89 | OPT_slp_max_runtime_alias_checks, |
| 90 | OPT_slp_max_stride, |
| 91 | OPT_slp_max_vf, |
| 92 | OPT_slp_min_reg_size, |
| 93 | OPT_slp_min_strided_loads, |
| 94 | OPT_slp_min_strided_stores, |
| 95 | OPT_slp_min_tree_size, |
| 96 | OPT_slp_non_vectorizables_as_reductions, |
| 97 | OPT_slp_per_lane_gather_scale, |
| 98 | OPT_slp_phi_list_budget, |
| 99 | OPT_slp_phi_vectorization_budget, |
| 100 | OPT_slp_postprocess_stores_operands, |
| 101 | OPT_slp_reassociate_ops, |
| 102 | OPT_slp_reassociate_reorder_limit, |
| 103 | OPT_slp_recursion_max_depth, |
| 104 | OPT_slp_reduction_budget, |
| 105 | OPT_slp_revec, |
| 106 | OPT_slp_runtime_alias_checks_max_scalar_cost_percent, |
| 107 | OPT_slp_schedule_budget, |
| 108 | OPT_slp_split_alternate_instructions, |
| 109 | OPT_slp_threshold, |
| 110 | OPT_slp_vec_loop_rt_checks_cost_percent, |
| 111 | OPT_slp_vectorize_hor_store, |
| 112 | OPT_slp_vectorize_hor, |
| 113 | OPT_slp_vectorize_loop_acc_rdx, |
| 114 | OPT_slp_vectorize_non_power_of_2, |
| 115 | OPT_slp_vectorize_once_used, |
| 116 | OPT_slp_vectorize_poor_throughput, |
| 117 | OPT_slp_vectorize_with_runtime_alias_checks, |
| 118 | OPT_small_loop_cost, |
| 119 | OPT_tail_folding_policy, |
| 120 | OPT_use_partial_reductions_by_default, |
| 121 | OPT_vector_combine_max_scan_instrs, |
| 122 | OPT_vectorize_loops, |
| 123 | OPT_vectorize_num_stores_pred, |
| 124 | OPT_vectorize_scev_check_threshold, |
| 125 | OPT_vectorize_slp, |
| 126 | OPT_vectorizer_consider_reg_pressure, |
| 127 | OPT_vectorizer_maximize_bandwidth_for_vector_calls, |
| 128 | OPT_vectorizer_maximize_bandwidth, |
| 129 | OPT_vectorizer_min_trip_count, |
| 130 | OPT_view_slp_tree, |
| 131 | OPT_vplan_build_outerloop_stress_test, |
| 132 | OPT_vplan_outer_loop_legality_checks, |
| 133 | #if !defined(NDEBUG) |
| 134 | OPT_vplan_print_after_all, |
| 135 | #endif |
| 136 | #if !defined(NDEBUG) |
| 137 | OPT_vplan_print_after, |
| 138 | #endif |
| 139 | #if !defined(NDEBUG) |
| 140 | OPT_vplan_print_before_all, |
| 141 | #endif |
| 142 | #if !defined(NDEBUG) |
| 143 | OPT_vplan_print_before, |
| 144 | #endif |
| 145 | OPT_vplan_print_in_dot_format, |
| 146 | #if !defined(NDEBUG) |
| 147 | OPT_vplan_print_vector_region_scope, |
| 148 | #endif |
| 149 | OPT_vplan_verify_each, |
| 150 | }; |
| 151 | } // namespace |
| 152 | |
| 153 | static llvm::opt::OptTable::Tables optionTables() { |
| 154 | using llvm::opt::DefaultVis, llvm::opt::HelpHidden, |
| 155 | llvm::opt::RenderAsInput, llvm::opt::RenderJoined, |
| 156 | llvm::opt::RenderSeparate; |
| 157 | |
| 158 | #ifdef __GNUC__ |
| 159 | #pragma GCC diagnostic push |
| 160 | #pragma GCC diagnostic ignored "-Woverlength-strings" |
| 161 | #endif |
| 162 | static constexpr char OptionStrTableStorage[] = |
| 163 | "\0" |
| 164 | "-\0" |
| 165 | "--\0" |
| 166 | "<input>\0" |
| 167 | "<unknown>\0" |
| 168 | "-disable-binop-extract-shuffle\0" |
| 169 | "Disable binop extract to shuffle transforms\0" |
| 170 | "-disable-loop-idiom-vectorize-all\0" |
| 171 | "Disable Loop Idiom Vectorize Pass\0" |
| 172 | "-disable-loop-idiom-vectorize-bytecmp\0" |
| 173 | "Proceed with Loop Idiom Vectorize Pass, but do not convert byte-compare loop(s)\0" |
| 174 | "-disable-loop-idiom-vectorize-find-first-byte\0" |
| 175 | "Do not convert find-first-byte loop(s)\0" |
| 176 | "-disable-vector-combine\0" |
| 177 | "Disable all vector combine transforms\0" |
| 178 | "-enable-early-exit-vectorization-with-side-effects\0" |
| 179 | "Enable vectorization of early exit loops with uncountable exits and side effects\0" |
| 180 | "-enable-early-exit-vectorization\0" |
| 181 | "Enable vectorization of early exit loops with uncountable exits\0" |
| 182 | "-enable-epilogue-vectorization\0" |
| 183 | "Enable vectorization of epilogue loops\0" |
| 184 | "-enable-histogram-loop-vectorization\0" |
| 185 | "Enables autovectorization of some loops containing histograms\0" |
| 186 | "-enable-if-conversion\0" |
| 187 | "Enable if-conversion during vectorization\0" |
| 188 | "-enable-ind-var-reg-heur\0" |
| 189 | "Count the induction variable only once when interleaving\0" |
| 190 | "-enable-interleave-to-reduce-stalls\0" |
| 191 | "When interleaving choose the interleave count that will reduce the stall cycles due to instruction latency to zero\0" |
| 192 | "-enable-interleaved-mem-accesses\0" |
| 193 | "Enable vectorization on interleaved memory accesses in a loop\0" |
| 194 | "-enable-loadstore-runtime-interleave\0" |
| 195 | "Enable runtime interleaving until load/store ports are saturated\0" |
| 196 | "-enable-masked-interleaved-mem-accesses\0" |
| 197 | "Enable vectorization on masked interleaved memory accesses in a loop\0" |
| 198 | "-enable-vplan-native-path\0" |
| 199 | "Enable VPlan-native vectorization path with support for outer loop vectorization\0" |
| 200 | "-epilogue-tail-folding-policy\0" |
| 201 | "Epilogue-tail-folding preferences over creating an epilogue loop\0" |
| 202 | "<dont-fold-tail|prefer-fold-tail>\0" |
| 203 | "dont-fold-tail,prefer-fold-tail\0" |
| 204 | "-epilogue-vectorization-minimum-VF\0" |
| 205 | "Only loops with vectorization factor equal to or larger than the specified value are considered for epilogue vectorization\0" |
| 206 | "-force-ordered-reductions\0" |
| 207 | "Enable the vectorisation of loops with in-order (strict) FP reductions\0" |
| 208 | "-force-partial-aliasing-vectorization\0" |
| 209 | "Replace pointer diff checks with alias masks\0" |
| 210 | "-force-tail-folding-style\0" |
| 211 | "Force the tail folding style\0" |
| 212 | "<none|data|data-without-lane-mask|data-and-control|data-with-evl>\0" |
| 213 | "none,data,data-without-lane-mask,data-and-control,data-with-evl\0" |
| 214 | "-force-target-instruction-cost\0" |
| 215 | "A flag that overrides the target's expected cost for an instruction to a single constant value. Mostly useful for getting consistent testing\0" |
| 216 | "-force-target-load-latency\0" |
| 217 | "A flag that overrides the target's expected latency for load instructions\0" |
| 218 | "-force-target-max-scalar-interleave\0" |
| 219 | "A flag that overrides the target's max interleave factor for scalar loops\0" |
| 220 | "-force-target-max-vector-interleave\0" |
| 221 | "A flag that overrides the target's max interleave factor for vectorized loops\0" |
| 222 | "-force-target-num-scalar-regs\0" |
| 223 | "A flag that overrides the target's number of scalar registers\0" |
| 224 | "-force-target-num-vector-regs\0" |
| 225 | "A flag that overrides the target's number of vector registers\0" |
| 226 | "-force-target-supports-gather-scatter-ops\0" |
| 227 | "Assume the target supports gather/scatter operations (used for testing)\0" |
| 228 | "-force-target-supports-masked-memory-ops\0" |
| 229 | "Assume the target supports masked memory operations (used for testing)\0" |
| 230 | "-force-target-supports-scalable-vectors\0" |
| 231 | "Pretend that scalable vectors are supported, even if the target does not support them. This flag should only be used for testing\0" |
| 232 | "-force-widen-divrem-via-masked-intrinsic\0" |
| 233 | "Override cost based masked intrinsic widening for div/rem instructions\0" |
| 234 | "-hints-allow-reordering\0" |
| 235 | "Allow enabling loop hints to reorder FP operations during vectorization\0" |
| 236 | "-interleave-loops\0" |
| 237 | "Enable loop interleaving in Loop vectorization passes\0" |
| 238 | "-loop-idiom-vectorize-bytecmp-vf\0" |
| 239 | "The vectorization factor for byte-compare patterns\0" |
| 240 | "-loop-idiom-vectorize-style\0" |
| 241 | "The vectorization style for loop idiom transform\0" |
| 242 | "<masked|predicated>\0" |
| 243 | "masked,predicated\0" |
| 244 | "-loop-idiom-vectorize-verify\0" |
| 245 | "Verify loops generated Loop Idiom Vectorize Pass\0" |
| 246 | "-loop-vectorize-with-block-frequency\0" |
| 247 | "Enable the use of the block frequency analysis to access PGO heuristics minimizing code growth in cold regions and being more aggressive in hot regions\0" |
| 248 | "-low-trip-count-loop-body-size-limit\0" |
| 249 | "Minimum number of instructions to vectorize loops with trip counts below tail folding threshold\0" |
| 250 | "-lv-compressing-patterns\0" |
| 251 | "Enable recognition of compressing patterns\0" |
| 252 | "-lv-strided-pointer-ivs\0" |
| 253 | "Enable recognition of non-constant strided pointer induction variables\0" |
| 254 | "-max-nested-scalar-reduction-interleave\0" |
| 255 | "The maximum interleave count to use when interleaving a scalar reduction in a nested loop\0" |
| 256 | "-pragma-vectorize-scev-check-threshold\0" |
| 257 | "The maximum number of SCEV checks allowed with a vectorize(enable) pragma\0" |
| 258 | "-prefer-inloop-reductions\0" |
| 259 | "Prefer in-loop vector reductions, overriding the targets preference\0" |
| 260 | "-prefer-predicated-reduction-select\0" |
| 261 | "Prefer predicating a reduction operation over an after loop select\0" |
| 262 | "-sbvec-allow-files\0" |
| 263 | "Run the vectorizer only on file paths that match any in the list of comma-separated regex's\0" |
| 264 | "-sbvec-allow-non-pow2\0" |
| 265 | "Allow non-power-of-2 vectorization\0" |
| 266 | "-sbvec-always-verify\0" |
| 267 | "Helps find bugs by verifying the IR whenever we emit new instructions (*very* expensive)\0" |
| 268 | "-sbvec-collect-seeds\0" |
| 269 | "Collect these seeds. Use empty for none or a comma-separated list of 'stores' and 'loads'\0" |
| 270 | "-sbvec-cost-threshold\0" |
| 271 | "Vectorization cost threshold\0" |
| 272 | "-sbvec-max-users-to-consider\0" |
| 273 | "Limit the number of a seed's users that getNextUserBundles() will examine as candidates for a matching bundle, to cap compilation time\0" |
| 274 | "-sbvec-passes\0" |
| 275 | "Comma-separated list of vectorizer passes. If not set we run the predefined pipeline\0" |
| 276 | "-sbvec-print-pass-pipeline\0" |
| 277 | "Prints the pass pipeline and returns\0" |
| 278 | "-sbvec-seed-bundle-size-limit\0" |
| 279 | "Limit the size of the seed bundle to cap compilation time\0" |
| 280 | "-sbvec-seed-groups-limit\0" |
| 281 | "Limit the number of collected seeds groups in a BB to cap compilation time\0" |
| 282 | "-sbvec-stop-at\0" |
| 283 | "Vectorize if the invocation count is < than this. 0 disables vectorization\0" |
| 284 | "-sbvec-stop-bndl\0" |
| 285 | "Vectorize up to this many bundles\0" |
| 286 | "-sbvec-vec-reg-bits\0" |
| 287 | "Override the vector register size in bits, which is otherwise found by querying TTI\0" |
| 288 | "-scalable-epilogue-vf-cost-scale-factor\0" |
| 289 | "Scale the cost of scalable epilogue VFs by this factor\0" |
| 290 | "-scalable-vectorization\0" |
| 291 | "Control whether the compiler can use scalable vectors to vectorize a loop. This does not override loop pragmas.\0" |
| 292 | "<off|preferred|on|always>\0" |
| 293 | "off,preferred,on,always\0" |
| 294 | "-slp-copyable-elements\0" |
| 295 | "Try to replace values with the idempotent instructions for better vectorization\0" |
| 296 | "-slp-cost-loop-trip-count\0" |
| 297 | "Loop trip count, considered by the cost model during modeling (0=loops are ignored and considered flat code)\0" |
| 298 | "-slp-disable-tree-reorder\0" |
| 299 | "Disable tree reordering even if it is profitable. Used for testing only\0" |
| 300 | "-slp-enable-masked-stores\0" |
| 301 | "Enable vectorization of non-consecutive stores as a single masked store, when the target supports masked stores\0" |
| 302 | "-slp-enable-strided-stores\0" |
| 303 | "Enable SLP trees to be built from strided store chains\0" |
| 304 | "-slp-force-strided-loads\0" |
| 305 | "Generate strided loads even if they are not profitable. Used for testing only\0" |
| 306 | "-slp-inst-count-check\0" |
| 307 | "Reject vectorization if vector instruction count exceeds scalar instruction count\0" |
| 308 | "-slp-max-look-ahead-depth\0" |
| 309 | "The maximum look-ahead depth for operand reordering scores\0" |
| 310 | "-slp-max-reg-size\0" |
| 311 | "Attempt to vectorize for this register size in bits\0" |
| 312 | "-slp-max-root-look-ahead-depth\0" |
| 313 | "The maximum look-ahead depth for searching best rooting option\0" |
| 314 | "-slp-max-runtime-alias-checks\0" |
| 315 | "The maximum number of runtime alias checks generated to guard a single SLP-vectorized region\0" |
| 316 | "-slp-max-stride\0" |
| 317 | "The maximum stride, considered to be profitable\0" |
| 318 | "-slp-max-vf\0" |
| 319 | "Maximum SLP vectorization factor (0=unlimited)\0" |
| 320 | "-slp-min-reg-size\0" |
| 321 | "-slp-min-strided-loads\0" |
| 322 | "The minimum number of loads, which should be considered strided, if the stride is > 1 or is runtime value\0" |
| 323 | "-slp-min-strided-stores\0" |
| 324 | "The minimum number of stores, which should be considered strided, if the stride is > 1 or is runtime value\0" |
| 325 | "-slp-min-tree-size\0" |
| 326 | "Only vectorize small trees if they are fully vectorizable\0" |
| 327 | "-slp-non-vectorizables-as-reductions\0" |
| 328 | "Use non-vectorizable instructions as potential reduction roots\0" |
| 329 | "-slp-per-lane-gather-scale\0" |
| 330 | "Use per-lane execution scale for gather/buildvector tree entries to model LICM-hoistable buildvector sequences\0" |
| 331 | "-slp-phi-list-budget\0" |
| 332 | "Maximum size of the phi list to be vectorized\0" |
| 333 | "-slp-phi-vectorization-budget\0" |
| 334 | "Do not vectorize a bundle of PHI nodes if the product of the bundle size and the number of incoming values exceeds this value, to limit the compile time spent on wide PHIs\0" |
| 335 | "-slp-postprocess-stores-operands\0" |
| 336 | "Force vectorization of non-vectorizable stores operands\0" |
| 337 | "-slp-reassociate-ops\0" |
| 338 | "Gather operands of associative binary chains into one node\0" |
| 339 | "-slp-reassociate-reorder-limit\0" |
| 340 | "Max flattened operand columns for which associative-chain reordering runs the full operand reorder\0" |
| 341 | "-slp-recursion-max-depth\0" |
| 342 | "Limit the recursion depth when building a vectorizable tree\0" |
| 343 | "-slp-reduction-budget\0" |
| 344 | "Limit the number of scalars in the rejected trees of the same reduction\0" |
| 345 | "-slp-revec\0" |
| 346 | "Enable vectorization for wider vector utilization\0" |
| 347 | "-slp-runtime-alias-checks-max-scalar-cost-percent\0" |
| 348 | "Maximum SLP runtime alias check cost, as a percentage of the guarded scalar region cost, before versioning is rejected to avoid pessimizing the scalar fallback path\0" |
| 349 | "-slp-schedule-budget\0" |
| 350 | "Limit the size of the SLP scheduling region per block\0" |
| 351 | "-slp-split-alternate-instructions\0" |
| 352 | "Improve the code quality by splitting alternate instructions\0" |
| 353 | "-slp-threshold\0" |
| 354 | "Only vectorize if you gain more than this number\0" |
| 355 | "-slp-vec-loop-rt-checks-cost-percent\0" |
| 356 | "Maximum SLP runtime alias check cost, as a percentage of the guarded scalar region cost, for blocks of loops already vectorized by the loop vectorizer\0" |
| 357 | "-slp-vectorize-hor-store\0" |
| 358 | "Attempt to vectorize horizontal reductions feeding into a store\0" |
| 359 | "-slp-vectorize-hor\0" |
| 360 | "Attempt to vectorize horizontal reductions\0" |
| 361 | "-slp-vectorize-loop-acc-rdx\0" |
| 362 | "Emit loop-carried horizontal reductions as a vector accumulator in the loop plus a single reduction after it\0" |
| 363 | "-slp-vectorize-non-power-of-2\0" |
| 364 | "Try to vectorize with non-power-of-2 number of elements\0" |
| 365 | "-slp-vectorize-once-used\0" |
| 366 | "Use instructions with the single user as standalone vectorization seeds\0" |
| 367 | "-slp-vectorize-poor-throughput\0" |
| 368 | "Use poor-throughput instructions (e.g. fdiv, frem, fsqrt) as standalone vectorization seeds\0" |
| 369 | "-slp-vectorize-with-runtime-alias-checks\0" |
| 370 | "Allow SLP to version a block with runtime alias checks to vectorize trees blocked by may-alias memory dependencies\0" |
| 371 | "-small-loop-cost\0" |
| 372 | "The cost of a loop that is considered 'small' by the interleaver\0" |
| 373 | "-tail-folding-policy\0" |
| 374 | "Tail-folding preferences over creating an epilogue loop\0" |
| 375 | "<dont-fold-tail|prefer-fold-tail|must-fold-tail>\0" |
| 376 | "dont-fold-tail,prefer-fold-tail,must-fold-tail\0" |
| 377 | "-use-partial-reductions-by-default\0" |
| 378 | "Use partial reduction intrinsics for all supported unordered reductions\0" |
| 379 | "-vector-combine-max-scan-instrs\0" |
| 380 | "Max number of instructions to scan for vector combining\0" |
| 381 | "-vectorize-loops\0" |
| 382 | "Run the Loop vectorization passes\0" |
| 383 | "-vectorize-num-stores-pred\0" |
| 384 | "Max number of stores to be predicated behind an if\0" |
| 385 | "-vectorize-scev-check-threshold\0" |
| 386 | "The maximum number of SCEV checks allowed\0" |
| 387 | "-vectorize-slp\0" |
| 388 | "Run the SLP vectorization passes\0" |
| 389 | "-vectorizer-consider-reg-pressure\0" |
| 390 | "Discard VFs if their register pressure is too high\0" |
| 391 | "-vectorizer-maximize-bandwidth-for-vector-calls\0" |
| 392 | "Try wider VFs if they enable the use of vector variants\0" |
| 393 | "-vectorizer-maximize-bandwidth\0" |
| 394 | "Maximize bandwidth when selecting vectorization factor which will be determined by the smallest type in loop\0" |
| 395 | "-vectorizer-min-trip-count\0" |
| 396 | "Loops with a constant trip count that is smaller than this value are vectorized only if no scalar epilogue is required\0" |
| 397 | "-view-slp-tree\0" |
| 398 | "Display the SLP trees with Graphviz\0" |
| 399 | "-vplan-build-outerloop-stress-test\0" |
| 400 | "Build VPlan for every supported loop nest in the function and bail out right after the build (stress test the VPlan H-CFG construction in the VPlan-native vectorization path)\0" |
| 401 | "-vplan-outer-loop-legality-checks\0" |
| 402 | "Check that the memory accesses of outer loops are safe to vectorize, instead of trusting the explicit vectorization pragma\0" |
| 403 | "-vplan-print-after-all\0" |
| 404 | "Print VPlans after all VPlan transformations\0" |
| 405 | "-vplan-print-after\0" |
| 406 | "Print VPlans after specified VPlan transformations (regexp)\0" |
| 407 | "-vplan-print-before-all\0" |
| 408 | "Print VPlans before all VPlan transformations\0" |
| 409 | "-vplan-print-before\0" |
| 410 | "Print VPlans before specified VPlan transformations (regexp)\0" |
| 411 | "-vplan-print-in-dot-format\0" |
| 412 | "Use dot format instead of plain text when dumping VPlans\0" |
| 413 | "-vplan-print-vector-region-scope\0" |
| 414 | "Limit VPlan printing to vector loop region in `-vplan-print-after*` if the plan has one\0" |
| 415 | "-vplan-verify-each\0" |
| 416 | "Verify VPlans after VPlan transforms\0" |
| 417 | ; |
| 418 | #ifdef __GNUC__ |
| 419 | #pragma GCC diagnostic pop |
| 420 | #endif |
| 421 | |
| 422 | static constexpr llvm::StringTable |
| 423 | OptionStrTable = OptionStrTableStorage; |
| 424 | |
| 425 | static constexpr llvm::StringTable::Offset OptionPrefixesTable[] = { |
| 426 | 0 /* prefixes */, |
| 427 | 2 /* prefixes */, 1 /* '-' */, 3 /* '--' */ |
| 428 | }; |
| 429 | |
| 430 | static constexpr llvm::opt::OptTable::HelpTextVariant OptionHelpTextVariantsTable[] = { |
| 431 | {0, 0}, |
| 432 | }; |
| 433 | |
| 434 | static constexpr unsigned OptionSubCommandIDsTable[] = { |
| 435 | 0 /* subcommands */ |
| 436 | }; |
| 437 | |
| 438 | static constexpr llvm::opt::OptTable::InfoExtra OptionInfoExtrasTable[] = { |
| 439 | {0, 0, 0, 0, 0, 0, 0, 0}, |
| 440 | {0, 0, 0, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 441 | {1635, 0, 1669, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 442 | {2094, 0, 2160, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 443 | {3741, 0, 3761, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 444 | {6213, 0, 6239, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 445 | {10469, 0, 10518, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0}, |
| 446 | }; |
| 447 | |
| 448 | static constexpr llvm::opt::OptTable::Info OptionInfoTable[] = { |
| 449 | {6 /* <input> */, 0, 0, 0, 1, 0, llvm::opt::Option::InputClass}, |
| 450 | {14 /* <unknown> */, 0, 0, 0, 1, 0, llvm::opt::Option::UnknownClass}, |
| 451 | {24 /* -disable-binop-extract-shuffle */, 55, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 452 | {99 /* -disable-loop-idiom-vectorize-all */, 133, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 453 | {167 /* -disable-loop-idiom-vectorize-bytecmp */, 205, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 454 | {285 /* -disable-loop-idiom-vectorize-find-first-byte */, 331, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 455 | {370 /* -disable-vector-combine */, 394, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 456 | {432 /* -enable-early-exit-vectorization-with-side-effects */, 483, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 457 | {564 /* -enable-early-exit-vectorization */, 597, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 458 | {661 /* -enable-epilogue-vectorization */, 692, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 459 | {731 /* -enable-histogram-loop-vectorization */, 768, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 460 | {830 /* -enable-if-conversion */, 852, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 461 | {894 /* -enable-ind-var-reg-heur */, 919, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 462 | {976 /* -enable-interleave-to-reduce-stalls */, 1012, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 463 | {1127 /* -enable-interleaved-mem-accesses */, 1160, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 464 | {1222 /* -enable-loadstore-runtime-interleave */, 1259, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 465 | {1324 /* -enable-masked-interleaved-mem-accesses */, 1364, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 466 | {1433 /* -enable-vplan-native-path */, 1459, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 467 | {1540 /* -epilogue-tail-folding-policy */, 1570, 0, 0, 2, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 468 | {1701 /* -epilogue-vectorization-minimum-VF */, 1736, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 469 | {1859 /* -force-ordered-reductions */, 1885, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 470 | {1956 /* -force-partial-aliasing-vectorization */, 1994, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 471 | {2039 /* -force-tail-folding-style */, 2065, 0, 0, 3, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 472 | {2224 /* -force-target-instruction-cost */, 2255, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 473 | {2396 /* -force-target-load-latency */, 2423, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 474 | {2497 /* -force-target-max-scalar-interleave */, 2533, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 475 | {2607 /* -force-target-max-vector-interleave */, 2643, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 476 | {2721 /* -force-target-num-scalar-regs */, 2751, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 477 | {2813 /* -force-target-num-vector-regs */, 2843, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 478 | {2905 /* -force-target-supports-gather-scatter-ops */, 2947, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 479 | {3019 /* -force-target-supports-masked-memory-ops */, 3060, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 480 | {3131 /* -force-target-supports-scalable-vectors */, 3171, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 481 | {3300 /* -force-widen-divrem-via-masked-intrinsic */, 3341, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 482 | {3412 /* -hints-allow-reordering */, 3436, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 483 | {3508 /* -interleave-loops */, 3526, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 484 | {3580 /* -loop-idiom-vectorize-bytecmp-vf */, 3613, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 485 | {3664 /* -loop-idiom-vectorize-style */, 3692, 0, 0, 4, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 486 | {3779 /* -loop-idiom-vectorize-verify */, 3808, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 487 | {3857 /* -loop-vectorize-with-block-frequency */, 3894, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 488 | {4046 /* -low-trip-count-loop-body-size-limit */, 4083, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 489 | {4179 /* -lv-compressing-patterns */, 4204, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 490 | {4247 /* -lv-strided-pointer-ivs */, 4271, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 491 | {4342 /* -max-nested-scalar-reduction-interleave */, 4382, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 492 | {4472 /* -pragma-vectorize-scev-check-threshold */, 4511, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 493 | {4585 /* -prefer-inloop-reductions */, 4611, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 494 | {4679 /* -prefer-predicated-reduction-select */, 4715, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 495 | {4782 /* -sbvec-allow-files */, 4801, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 496 | {4893 /* -sbvec-allow-non-pow2 */, 4915, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 497 | #if !defined(NDEBUG) |
| 498 | {4950 /* -sbvec-always-verify */, 4971, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 499 | #endif |
| 500 | {5060 /* -sbvec-collect-seeds */, 5081, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 501 | {5171 /* -sbvec-cost-threshold */, 5193, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 502 | {5222 /* -sbvec-max-users-to-consider */, 5251, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 503 | {5386 /* -sbvec-passes */, 5400, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 504 | {5485 /* -sbvec-print-pass-pipeline */, 5512, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 505 | {5549 /* -sbvec-seed-bundle-size-limit */, 5579, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 506 | {5637 /* -sbvec-seed-groups-limit */, 5662, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 507 | {5737 /* -sbvec-stop-at */, 5752, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 508 | {5827 /* -sbvec-stop-bndl */, 5844, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 509 | {5878 /* -sbvec-vec-reg-bits */, 5898, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 510 | {5982 /* -scalable-epilogue-vf-cost-scale-factor */, 6022, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 511 | {6077 /* -scalable-vectorization */, 6101, 0, 0, 5, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 512 | {6263 /* -slp-copyable-elements */, 6286, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 513 | {6366 /* -slp-cost-loop-trip-count */, 6392, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 514 | {6501 /* -slp-disable-tree-reorder */, 6527, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 515 | {6599 /* -slp-enable-masked-stores */, 6625, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 516 | {6737 /* -slp-enable-strided-stores */, 6764, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 517 | {6819 /* -slp-force-strided-loads */, 6844, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 518 | {6922 /* -slp-inst-count-check */, 6944, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 519 | {7026 /* -slp-max-look-ahead-depth */, 7052, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 520 | {7111 /* -slp-max-reg-size */, 7129, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 521 | {7181 /* -slp-max-root-look-ahead-depth */, 7212, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 522 | {7275 /* -slp-max-runtime-alias-checks */, 7305, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 523 | {7398 /* -slp-max-stride */, 7414, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 524 | {7462 /* -slp-max-vf */, 7474, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 525 | {7521 /* -slp-min-reg-size */, 7129, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 526 | {7539 /* -slp-min-strided-loads */, 7562, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 527 | {7668 /* -slp-min-strided-stores */, 7692, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 528 | {7799 /* -slp-min-tree-size */, 7818, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 529 | {7876 /* -slp-non-vectorizables-as-reductions */, 7913, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 530 | {7977 /* -slp-per-lane-gather-scale */, 8004, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 531 | {8115 /* -slp-phi-list-budget */, 8136, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 532 | {8182 /* -slp-phi-vectorization-budget */, 8212, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 533 | {8384 /* -slp-postprocess-stores-operands */, 8417, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 534 | {8473 /* -slp-reassociate-ops */, 8494, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 535 | {8553 /* -slp-reassociate-reorder-limit */, 8584, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 536 | {8683 /* -slp-recursion-max-depth */, 8708, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 537 | {8768 /* -slp-reduction-budget */, 8790, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 538 | {8862 /* -slp-revec */, 8873, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 539 | {8923 /* -slp-runtime-alias-checks-max-scalar-cost-percent */, 8973, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 540 | {9138 /* -slp-schedule-budget */, 9159, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 541 | {9213 /* -slp-split-alternate-instructions */, 9247, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 542 | {9308 /* -slp-threshold */, 9323, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 543 | {9372 /* -slp-vec-loop-rt-checks-cost-percent */, 9409, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 544 | {9560 /* -slp-vectorize-hor-store */, 9585, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 545 | {9649 /* -slp-vectorize-hor */, 9668, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 546 | {9711 /* -slp-vectorize-loop-acc-rdx */, 9739, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 547 | {9848 /* -slp-vectorize-non-power-of-2 */, 9878, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 548 | {9934 /* -slp-vectorize-once-used */, 9959, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 549 | {10031 /* -slp-vectorize-poor-throughput */, 10062, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 550 | {10154 /* -slp-vectorize-with-runtime-alias-checks */, 10195, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 551 | {10310 /* -small-loop-cost */, 10327, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 552 | {10392 /* -tail-folding-policy */, 10413, 0, 0, 6, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 553 | {10565 /* -use-partial-reductions-by-default */, 10600, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 554 | {10672 /* -vector-combine-max-scan-instrs */, 10704, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 555 | {10760 /* -vectorize-loops */, 10777, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 556 | {10811 /* -vectorize-num-stores-pred */, 10838, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 557 | {10889 /* -vectorize-scev-check-threshold */, 10921, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 558 | {10963 /* -vectorize-slp */, 10978, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 559 | {11011 /* -vectorizer-consider-reg-pressure */, 11045, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 560 | {11096 /* -vectorizer-maximize-bandwidth-for-vector-calls */, 11144, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 561 | {11200 /* -vectorizer-maximize-bandwidth */, 11231, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 562 | {11340 /* -vectorizer-min-trip-count */, 11367, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 563 | {11486 /* -view-slp-tree */, 11501, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 564 | {11537 /* -vplan-build-outerloop-stress-test */, 11572, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 565 | {11747 /* -vplan-outer-loop-legality-checks */, 11781, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 566 | #if !defined(NDEBUG) |
| 567 | {11904 /* -vplan-print-after-all */, 11927, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 568 | #endif |
| 569 | #if !defined(NDEBUG) |
| 570 | {11972 /* -vplan-print-after */, 11991, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 571 | #endif |
| 572 | #if !defined(NDEBUG) |
| 573 | {12051 /* -vplan-print-before-all */, 12075, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 574 | #endif |
| 575 | #if !defined(NDEBUG) |
| 576 | {12121 /* -vplan-print-before */, 12141, 0, 0, 1, 1, llvm::opt::Option::SeparateOrEqClass}, |
| 577 | #endif |
| 578 | {12202 /* -vplan-print-in-dot-format */, 12229, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 579 | #if !defined(NDEBUG) |
| 580 | {12286 /* -vplan-print-vector-region-scope */, 12319, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 581 | #endif |
| 582 | {12407 /* -vplan-verify-each */, 12426, 0, 0, 1, 1, llvm::opt::Option::FlagOrEqClass}, |
| 583 | }; |
| 584 | |
| 585 | return {OptionStrTable, OptionPrefixesTable, |
| 586 | OptionInfoTable, OptionInfoExtrasTable, OptionHelpTextVariantsTable, {}, OptionSubCommandIDsTable}; |
| 587 | } |
| 588 | #undef OPTTABLE_CODE |
| 589 | #endif // OPTTABLE_CODE || OPTIONS_STRUCT_DEFS |
| 590 | |
| 591 | |
| 592 | #ifdef OPTIONS_STRUCT_DECL |
| 593 | #undef OPTIONS_STRUCT_DECL |
| 594 | #include "llvm/ADT/ArrayRef.h" |
| 595 | #include "llvm/ADT/BoolOrDefault.h" |
| 596 | #include "llvm/ADT/StringRef.h" |
| 597 | #include "llvm/Support/Allocator.h" |
| 598 | #include "llvm/Support/LibraryOptionsContext.h" |
| 599 | |
| 600 | namespace llvm { |
| 601 | namespace opt { |
| 602 | class Arg; |
| 603 | class LibraryOptionsParser; |
| 604 | class OptTable; |
| 605 | } // namespace opt |
| 606 | } // namespace llvm |
| 607 | |
| 608 | namespace llvm { |
| 609 | struct VectorizeOptions { |
| 610 | bool disable_loop_idiom_vectorize_all{false}; |
| 611 | bool disable_loop_idiom_vectorize_bytecmp{false}; |
| 612 | bool disable_loop_idiom_vectorize_find_first_byte{false}; |
| 613 | std::optional<unsigned> loop_idiom_vectorize_bytecmp_vf{}; |
| 614 | std::optional<LoopIdiomVectorizeStyle> loop_idiom_vectorize_style{}; |
| 615 | bool loop_idiom_vectorize_verify{false}; |
| 616 | bool enable_histogram_loop_vectorization{false}; |
| 617 | bool enable_if_conversion{true}; |
| 618 | bool hints_allow_reordering{true}; |
| 619 | bool lv_strided_pointer_ivs{false}; |
| 620 | bool lv_compressing_patterns{true}; |
| 621 | LoopVectorizeHints::ScalableForceKind scalable_vectorization{LoopVectorizeHints::SK_Unspecified}; |
| 622 | bool force_target_supports_gather_scatter_ops{false}; |
| 623 | bool force_target_supports_masked_memory_ops{false}; |
| 624 | bool force_target_supports_scalable_vectors{false}; |
| 625 | bool prefer_inloop_reductions{false}; |
| 626 | float scalable_epilogue_vf_cost_scale_factor{2.0f}; |
| 627 | llvm::BoolOrDefault vectorizer_consider_reg_pressure{llvm::BoolOrDefault::Default}; |
| 628 | llvm::BoolOrDefault vectorizer_maximize_bandwidth{llvm::BoolOrDefault::Default}; |
| 629 | bool vectorizer_maximize_bandwidth_for_vector_calls{true}; |
| 630 | bool enable_early_exit_vectorization{true}; |
| 631 | bool enable_early_exit_vectorization_with_side_effects{false}; |
| 632 | bool enable_epilogue_vectorization{true}; |
| 633 | bool enable_ind_var_reg_heur{true}; |
| 634 | bool enable_interleave_to_reduce_stalls{false}; |
| 635 | llvm::BoolOrDefault enable_interleaved_mem_accesses{llvm::BoolOrDefault::Default}; |
| 636 | bool enable_loadstore_runtime_interleave{true}; |
| 637 | llvm::BoolOrDefault enable_masked_interleaved_mem_accesses{llvm::BoolOrDefault::Default}; |
| 638 | bool enable_vplan_native_path{false}; |
| 639 | std::optional<TailFoldingPolicyTy> epilogue_tail_folding_policy{}; |
| 640 | std::optional<unsigned> epilogue_vectorization_minimum_VF{}; |
| 641 | llvm::BoolOrDefault force_ordered_reductions{llvm::BoolOrDefault::Default}; |
| 642 | bool force_partial_aliasing_vectorization{false}; |
| 643 | std::optional<TailFoldingStyle> force_tail_folding_style{}; |
| 644 | std::optional<unsigned> force_target_instruction_cost{}; |
| 645 | unsigned force_target_load_latency{0}; |
| 646 | std::optional<unsigned> force_target_max_scalar_interleave{}; |
| 647 | std::optional<unsigned> force_target_max_vector_interleave{}; |
| 648 | std::optional<unsigned> force_target_num_scalar_regs{}; |
| 649 | std::optional<unsigned> force_target_num_vector_regs{}; |
| 650 | llvm::BoolOrDefault force_widen_divrem_via_masked_intrinsic{llvm::BoolOrDefault::Default}; |
| 651 | bool interleave_loops{true}; |
| 652 | bool loop_vectorize_with_block_frequency{true}; |
| 653 | unsigned low_trip_count_loop_body_size_limit{20}; |
| 654 | unsigned max_nested_scalar_reduction_interleave{2}; |
| 655 | unsigned pragma_vectorize_scev_check_threshold{128}; |
| 656 | bool prefer_predicated_reduction_select{false}; |
| 657 | unsigned small_loop_cost{20}; |
| 658 | std::optional<TailFoldingPolicyTy> tail_folding_policy{}; |
| 659 | bool vectorize_loops{true}; |
| 660 | unsigned vectorize_num_stores_pred{1}; |
| 661 | unsigned vectorize_scev_check_threshold{16}; |
| 662 | unsigned vectorizer_min_trip_count{16}; |
| 663 | bool vplan_build_outerloop_stress_test{false}; |
| 664 | bool vplan_outer_loop_legality_checks{false}; |
| 665 | #if !defined(NDEBUG) |
| 666 | llvm::ArrayRef<StringRef> vplan_print_after{}; |
| 667 | #endif |
| 668 | #if !defined(NDEBUG) |
| 669 | bool vplan_print_after_all{false}; |
| 670 | #endif |
| 671 | #if !defined(NDEBUG) |
| 672 | llvm::ArrayRef<StringRef> vplan_print_before{}; |
| 673 | #endif |
| 674 | #if !defined(NDEBUG) |
| 675 | bool vplan_print_before_all{false}; |
| 676 | #endif |
| 677 | #if !defined(NDEBUG) |
| 678 | bool vplan_print_vector_region_scope{false}; |
| 679 | #endif |
| 680 | bool vplan_verify_each{VPlanVerifyEachDefault}; |
| 681 | #if !defined(NDEBUG) |
| 682 | bool sbvec_always_verify{false}; |
| 683 | #endif |
| 684 | unsigned long sbvec_stop_at{SBVecStopDisabled}; |
| 685 | unsigned long sbvec_stop_bndl{SBVecStopDisabled}; |
| 686 | bool sbvec_allow_non_pow2{false}; |
| 687 | StringRef sbvec_collect_seeds{"stores" }; |
| 688 | unsigned sbvec_vec_reg_bits{0}; |
| 689 | int sbvec_cost_threshold{0}; |
| 690 | StringRef sbvec_allow_files{".*" }; |
| 691 | StringRef sbvec_passes{"*" }; |
| 692 | bool sbvec_print_pass_pipeline{false}; |
| 693 | unsigned sbvec_seed_bundle_size_limit{32}; |
| 694 | unsigned sbvec_seed_groups_limit{256}; |
| 695 | unsigned sbvec_max_users_to_consider{16}; |
| 696 | bool slp_copyable_elements{true}; |
| 697 | unsigned slp_cost_loop_trip_count{2}; |
| 698 | bool slp_disable_tree_reorder{false}; |
| 699 | bool slp_enable_masked_stores{true}; |
| 700 | bool slp_enable_strided_stores{false}; |
| 701 | bool slp_force_strided_loads{false}; |
| 702 | bool slp_inst_count_check{true}; |
| 703 | int slp_max_look_ahead_depth{2}; |
| 704 | std::optional<int> slp_max_reg_size{}; |
| 705 | int slp_max_root_look_ahead_depth{2}; |
| 706 | unsigned slp_max_runtime_alias_checks{8}; |
| 707 | unsigned slp_max_stride{8}; |
| 708 | std::optional<unsigned> slp_max_vf{}; |
| 709 | std::optional<int> slp_min_reg_size{}; |
| 710 | unsigned slp_min_strided_loads{2}; |
| 711 | unsigned slp_min_strided_stores{2}; |
| 712 | unsigned slp_min_tree_size{3}; |
| 713 | bool slp_non_vectorizables_as_reductions{false}; |
| 714 | bool slp_per_lane_gather_scale{true}; |
| 715 | unsigned slp_phi_list_budget{1024}; |
| 716 | unsigned slp_phi_vectorization_budget{1024}; |
| 717 | bool slp_postprocess_stores_operands{false}; |
| 718 | bool slp_reassociate_ops{true}; |
| 719 | unsigned slp_reassociate_reorder_limit{32}; |
| 720 | unsigned slp_recursion_max_depth{12}; |
| 721 | unsigned slp_reduction_budget{65536}; |
| 722 | bool slp_revec{false}; |
| 723 | unsigned slp_runtime_alias_checks_max_scalar_cost_percent{25}; |
| 724 | int slp_schedule_budget{200000}; |
| 725 | bool slp_split_alternate_instructions{true}; |
| 726 | std::optional<int> slp_threshold{}; |
| 727 | unsigned slp_vec_loop_rt_checks_cost_percent{10}; |
| 728 | bool slp_vectorize_hor{true}; |
| 729 | bool slp_vectorize_hor_store{false}; |
| 730 | bool slp_vectorize_loop_acc_rdx{true}; |
| 731 | bool slp_vectorize_non_power_of_2{false}; |
| 732 | bool slp_vectorize_once_used{true}; |
| 733 | bool slp_vectorize_poor_throughput{true}; |
| 734 | bool slp_vectorize_with_runtime_alias_checks{true}; |
| 735 | bool vectorize_slp{true}; |
| 736 | bool view_slp_tree{false}; |
| 737 | bool {false}; |
| 738 | bool disable_vector_combine{false}; |
| 739 | unsigned vector_combine_max_scan_instrs{30}; |
| 740 | bool vplan_print_in_dot_format{false}; |
| 741 | bool use_partial_reductions_by_default{false}; |
| 742 | |
| 743 | static const llvm::opt::OptTable &optTable(); |
| 744 | /// Sets the member that \p A names, allocating a list from \p Alloc. |
| 745 | /// Returns false if the value is invalid. |
| 746 | bool apply(const llvm::opt::Arg &A, llvm::BumpPtrAllocator &Alloc); |
| 747 | |
| 748 | private: |
| 749 | friend class llvm::cl::LibraryOptionsContext; |
| 750 | friend class llvm::opt::LibraryOptionsParser; |
| 751 | |
| 752 | static const VectorizeOptions Default; |
| 753 | }; |
| 754 | } // namespace llvm |
| 755 | #endif // OPTIONS_STRUCT_DECL |
| 756 | |
| 757 | #ifdef OPTIONS_STRUCT_DEFS |
| 758 | #undef OPTIONS_STRUCT_DEFS |
| 759 | LLVM_REQUIRE_CONSTANT_INITIALIZATION const llvm::VectorizeOptions llvm::VectorizeOptions::Default; |
| 760 | |
| 761 | const llvm::opt::OptTable &llvm::VectorizeOptions::optTable() { |
| 762 | static const llvm::opt::LibraryOptTable T(optionTables()); |
| 763 | return T; |
| 764 | } |
| 765 | |
| 766 | bool llvm::VectorizeOptions::apply(const llvm::opt::Arg &A, llvm::BumpPtrAllocator &Alloc) { |
| 767 | switch (A.getOption().getID()) { |
| 768 | case OPT_disable_binop_extract_shuffle: |
| 769 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , disable_binop_extract_shuffle, Alloc); |
| 770 | case OPT_disable_loop_idiom_vectorize_all: |
| 771 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , disable_loop_idiom_vectorize_all, Alloc); |
| 772 | case OPT_disable_loop_idiom_vectorize_bytecmp: |
| 773 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , disable_loop_idiom_vectorize_bytecmp, Alloc); |
| 774 | case OPT_disable_loop_idiom_vectorize_find_first_byte: |
| 775 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , disable_loop_idiom_vectorize_find_first_byte, Alloc); |
| 776 | case OPT_disable_vector_combine: |
| 777 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , disable_vector_combine, Alloc); |
| 778 | case OPT_enable_early_exit_vectorization_with_side_effects: |
| 779 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_early_exit_vectorization_with_side_effects, Alloc); |
| 780 | case OPT_enable_early_exit_vectorization: |
| 781 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_early_exit_vectorization, Alloc); |
| 782 | case OPT_enable_epilogue_vectorization: |
| 783 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_epilogue_vectorization, Alloc); |
| 784 | case OPT_enable_histogram_loop_vectorization: |
| 785 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_histogram_loop_vectorization, Alloc); |
| 786 | case OPT_enable_if_conversion: |
| 787 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_if_conversion, Alloc); |
| 788 | case OPT_enable_ind_var_reg_heur: |
| 789 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_ind_var_reg_heur, Alloc); |
| 790 | case OPT_enable_interleave_to_reduce_stalls: |
| 791 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_interleave_to_reduce_stalls, Alloc); |
| 792 | case OPT_enable_interleaved_mem_accesses: |
| 793 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_interleaved_mem_accesses, Alloc); |
| 794 | case OPT_enable_loadstore_runtime_interleave: |
| 795 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_loadstore_runtime_interleave, Alloc); |
| 796 | case OPT_enable_masked_interleaved_mem_accesses: |
| 797 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_masked_interleaved_mem_accesses, Alloc); |
| 798 | case OPT_enable_vplan_native_path: |
| 799 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , enable_vplan_native_path, Alloc); |
| 800 | case OPT_epilogue_tail_folding_policy: |
| 801 | return llvm::opt::parseArgValue(A.getValue(), epilogue_tail_folding_policy, Alloc, [](llvm::StringRef V, auto &X) { |
| 802 | if (V == "dont-fold-tail" ) { |
| 803 | X = TailFoldingPolicyTy::None; |
| 804 | return true; |
| 805 | } |
| 806 | if (V == "prefer-fold-tail" ) { |
| 807 | X = TailFoldingPolicyTy::PreferFoldTail; |
| 808 | return true; |
| 809 | } |
| 810 | return false; |
| 811 | }); |
| 812 | case OPT_epilogue_vectorization_minimum_VF: |
| 813 | return llvm::opt::parseArgValue(A.getValue(), epilogue_vectorization_minimum_VF, Alloc); |
| 814 | case OPT_force_ordered_reductions: |
| 815 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_ordered_reductions, Alloc); |
| 816 | case OPT_force_partial_aliasing_vectorization: |
| 817 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_partial_aliasing_vectorization, Alloc); |
| 818 | case OPT_force_tail_folding_style: |
| 819 | return llvm::opt::parseArgValue(A.getValue(), force_tail_folding_style, Alloc, [](llvm::StringRef V, auto &X) { |
| 820 | if (V == "none" ) { |
| 821 | X = TailFoldingStyle::None; |
| 822 | return true; |
| 823 | } |
| 824 | if (V == "data" ) { |
| 825 | X = TailFoldingStyle::Data; |
| 826 | return true; |
| 827 | } |
| 828 | if (V == "data-without-lane-mask" ) { |
| 829 | X = TailFoldingStyle::DataWithoutLaneMask; |
| 830 | return true; |
| 831 | } |
| 832 | if (V == "data-and-control" ) { |
| 833 | X = TailFoldingStyle::DataAndControlFlow; |
| 834 | return true; |
| 835 | } |
| 836 | if (V == "data-with-evl" ) { |
| 837 | X = TailFoldingStyle::DataWithEVL; |
| 838 | return true; |
| 839 | } |
| 840 | return false; |
| 841 | }); |
| 842 | case OPT_force_target_instruction_cost: |
| 843 | return llvm::opt::parseArgValue(A.getValue(), force_target_instruction_cost, Alloc); |
| 844 | case OPT_force_target_load_latency: |
| 845 | return llvm::opt::parseArgValue(A.getValue(), force_target_load_latency, Alloc); |
| 846 | case OPT_force_target_max_scalar_interleave: |
| 847 | return llvm::opt::parseArgValue(A.getValue(), force_target_max_scalar_interleave, Alloc); |
| 848 | case OPT_force_target_max_vector_interleave: |
| 849 | return llvm::opt::parseArgValue(A.getValue(), force_target_max_vector_interleave, Alloc); |
| 850 | case OPT_force_target_num_scalar_regs: |
| 851 | return llvm::opt::parseArgValue(A.getValue(), force_target_num_scalar_regs, Alloc); |
| 852 | case OPT_force_target_num_vector_regs: |
| 853 | return llvm::opt::parseArgValue(A.getValue(), force_target_num_vector_regs, Alloc); |
| 854 | case OPT_force_target_supports_gather_scatter_ops: |
| 855 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_target_supports_gather_scatter_ops, Alloc); |
| 856 | case OPT_force_target_supports_masked_memory_ops: |
| 857 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_target_supports_masked_memory_ops, Alloc); |
| 858 | case OPT_force_target_supports_scalable_vectors: |
| 859 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_target_supports_scalable_vectors, Alloc); |
| 860 | case OPT_force_widen_divrem_via_masked_intrinsic: |
| 861 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , force_widen_divrem_via_masked_intrinsic, Alloc); |
| 862 | case OPT_hints_allow_reordering: |
| 863 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , hints_allow_reordering, Alloc); |
| 864 | case OPT_interleave_loops: |
| 865 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , interleave_loops, Alloc); |
| 866 | case OPT_loop_idiom_vectorize_bytecmp_vf: |
| 867 | return llvm::opt::parseArgValue(A.getValue(), loop_idiom_vectorize_bytecmp_vf, Alloc); |
| 868 | case OPT_loop_idiom_vectorize_style: |
| 869 | return llvm::opt::parseArgValue(A.getValue(), loop_idiom_vectorize_style, Alloc, [](llvm::StringRef V, auto &X) { |
| 870 | if (V == "masked" ) { |
| 871 | X = LoopIdiomVectorizeStyle::Masked; |
| 872 | return true; |
| 873 | } |
| 874 | if (V == "predicated" ) { |
| 875 | X = LoopIdiomVectorizeStyle::Predicated; |
| 876 | return true; |
| 877 | } |
| 878 | return false; |
| 879 | }); |
| 880 | case OPT_loop_idiom_vectorize_verify: |
| 881 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , loop_idiom_vectorize_verify, Alloc); |
| 882 | case OPT_loop_vectorize_with_block_frequency: |
| 883 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , loop_vectorize_with_block_frequency, Alloc); |
| 884 | case OPT_low_trip_count_loop_body_size_limit: |
| 885 | return llvm::opt::parseArgValue(A.getValue(), low_trip_count_loop_body_size_limit, Alloc); |
| 886 | case OPT_lv_compressing_patterns: |
| 887 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , lv_compressing_patterns, Alloc); |
| 888 | case OPT_lv_strided_pointer_ivs: |
| 889 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , lv_strided_pointer_ivs, Alloc); |
| 890 | case OPT_max_nested_scalar_reduction_interleave: |
| 891 | return llvm::opt::parseArgValue(A.getValue(), max_nested_scalar_reduction_interleave, Alloc); |
| 892 | case OPT_pragma_vectorize_scev_check_threshold: |
| 893 | return llvm::opt::parseArgValue(A.getValue(), pragma_vectorize_scev_check_threshold, Alloc); |
| 894 | case OPT_prefer_inloop_reductions: |
| 895 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , prefer_inloop_reductions, Alloc); |
| 896 | case OPT_prefer_predicated_reduction_select: |
| 897 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , prefer_predicated_reduction_select, Alloc); |
| 898 | case OPT_sbvec_allow_files: |
| 899 | return llvm::opt::parseArgValue(A.getValue(), sbvec_allow_files, Alloc); |
| 900 | case OPT_sbvec_allow_non_pow2: |
| 901 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , sbvec_allow_non_pow2, Alloc); |
| 902 | #if !defined(NDEBUG) |
| 903 | case OPT_sbvec_always_verify: |
| 904 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , sbvec_always_verify, Alloc); |
| 905 | #endif |
| 906 | case OPT_sbvec_collect_seeds: |
| 907 | return llvm::opt::parseArgValue(A.getValue(), sbvec_collect_seeds, Alloc); |
| 908 | case OPT_sbvec_cost_threshold: |
| 909 | return llvm::opt::parseArgValue(A.getValue(), sbvec_cost_threshold, Alloc); |
| 910 | case OPT_sbvec_max_users_to_consider: |
| 911 | return llvm::opt::parseArgValue(A.getValue(), sbvec_max_users_to_consider, Alloc); |
| 912 | case OPT_sbvec_passes: |
| 913 | return llvm::opt::parseArgValue(A.getValue(), sbvec_passes, Alloc); |
| 914 | case OPT_sbvec_print_pass_pipeline: |
| 915 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , sbvec_print_pass_pipeline, Alloc); |
| 916 | case OPT_sbvec_seed_bundle_size_limit: |
| 917 | return llvm::opt::parseArgValue(A.getValue(), sbvec_seed_bundle_size_limit, Alloc); |
| 918 | case OPT_sbvec_seed_groups_limit: |
| 919 | return llvm::opt::parseArgValue(A.getValue(), sbvec_seed_groups_limit, Alloc); |
| 920 | case OPT_sbvec_stop_at: |
| 921 | return llvm::opt::parseArgValue(A.getValue(), sbvec_stop_at, Alloc); |
| 922 | case OPT_sbvec_stop_bndl: |
| 923 | return llvm::opt::parseArgValue(A.getValue(), sbvec_stop_bndl, Alloc); |
| 924 | case OPT_sbvec_vec_reg_bits: |
| 925 | return llvm::opt::parseArgValue(A.getValue(), sbvec_vec_reg_bits, Alloc); |
| 926 | case OPT_scalable_epilogue_vf_cost_scale_factor: |
| 927 | return llvm::opt::parseArgValue(A.getValue(), scalable_epilogue_vf_cost_scale_factor, Alloc); |
| 928 | case OPT_scalable_vectorization: |
| 929 | return llvm::opt::parseArgValue(A.getValue(), scalable_vectorization, Alloc, [](llvm::StringRef V, auto &X) { |
| 930 | if (V == "off" ) { |
| 931 | X = LoopVectorizeHints::SK_FixedWidthOnly; |
| 932 | return true; |
| 933 | } |
| 934 | if (V == "preferred" ) { |
| 935 | X = LoopVectorizeHints::SK_PreferScalable; |
| 936 | return true; |
| 937 | } |
| 938 | if (V == "on" ) { |
| 939 | X = LoopVectorizeHints::SK_PreferScalable; |
| 940 | return true; |
| 941 | } |
| 942 | if (V == "always" ) { |
| 943 | X = LoopVectorizeHints::SK_AlwaysScalable; |
| 944 | return true; |
| 945 | } |
| 946 | return false; |
| 947 | }); |
| 948 | case OPT_slp_copyable_elements: |
| 949 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_copyable_elements, Alloc); |
| 950 | case OPT_slp_cost_loop_trip_count: |
| 951 | return llvm::opt::parseArgValue(A.getValue(), slp_cost_loop_trip_count, Alloc); |
| 952 | case OPT_slp_disable_tree_reorder: |
| 953 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_disable_tree_reorder, Alloc); |
| 954 | case OPT_slp_enable_masked_stores: |
| 955 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_enable_masked_stores, Alloc); |
| 956 | case OPT_slp_enable_strided_stores: |
| 957 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_enable_strided_stores, Alloc); |
| 958 | case OPT_slp_force_strided_loads: |
| 959 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_force_strided_loads, Alloc); |
| 960 | case OPT_slp_inst_count_check: |
| 961 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_inst_count_check, Alloc); |
| 962 | case OPT_slp_max_look_ahead_depth: |
| 963 | return llvm::opt::parseArgValue(A.getValue(), slp_max_look_ahead_depth, Alloc); |
| 964 | case OPT_slp_max_reg_size: |
| 965 | return llvm::opt::parseArgValue(A.getValue(), slp_max_reg_size, Alloc); |
| 966 | case OPT_slp_max_root_look_ahead_depth: |
| 967 | return llvm::opt::parseArgValue(A.getValue(), slp_max_root_look_ahead_depth, Alloc); |
| 968 | case OPT_slp_max_runtime_alias_checks: |
| 969 | return llvm::opt::parseArgValue(A.getValue(), slp_max_runtime_alias_checks, Alloc); |
| 970 | case OPT_slp_max_stride: |
| 971 | return llvm::opt::parseArgValue(A.getValue(), slp_max_stride, Alloc); |
| 972 | case OPT_slp_max_vf: |
| 973 | return llvm::opt::parseArgValue(A.getValue(), slp_max_vf, Alloc); |
| 974 | case OPT_slp_min_reg_size: |
| 975 | return llvm::opt::parseArgValue(A.getValue(), slp_min_reg_size, Alloc); |
| 976 | case OPT_slp_min_strided_loads: |
| 977 | return llvm::opt::parseArgValue(A.getValue(), slp_min_strided_loads, Alloc); |
| 978 | case OPT_slp_min_strided_stores: |
| 979 | return llvm::opt::parseArgValue(A.getValue(), slp_min_strided_stores, Alloc); |
| 980 | case OPT_slp_min_tree_size: |
| 981 | return llvm::opt::parseArgValue(A.getValue(), slp_min_tree_size, Alloc); |
| 982 | case OPT_slp_non_vectorizables_as_reductions: |
| 983 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_non_vectorizables_as_reductions, Alloc); |
| 984 | case OPT_slp_per_lane_gather_scale: |
| 985 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_per_lane_gather_scale, Alloc); |
| 986 | case OPT_slp_phi_list_budget: |
| 987 | return llvm::opt::parseArgValue(A.getValue(), slp_phi_list_budget, Alloc); |
| 988 | case OPT_slp_phi_vectorization_budget: |
| 989 | return llvm::opt::parseArgValue(A.getValue(), slp_phi_vectorization_budget, Alloc); |
| 990 | case OPT_slp_postprocess_stores_operands: |
| 991 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_postprocess_stores_operands, Alloc); |
| 992 | case OPT_slp_reassociate_ops: |
| 993 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_reassociate_ops, Alloc); |
| 994 | case OPT_slp_reassociate_reorder_limit: |
| 995 | return llvm::opt::parseArgValue(A.getValue(), slp_reassociate_reorder_limit, Alloc); |
| 996 | case OPT_slp_recursion_max_depth: |
| 997 | return llvm::opt::parseArgValue(A.getValue(), slp_recursion_max_depth, Alloc); |
| 998 | case OPT_slp_reduction_budget: |
| 999 | return llvm::opt::parseArgValue(A.getValue(), slp_reduction_budget, Alloc); |
| 1000 | case OPT_slp_revec: |
| 1001 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_revec, Alloc); |
| 1002 | case OPT_slp_runtime_alias_checks_max_scalar_cost_percent: |
| 1003 | return llvm::opt::parseArgValue(A.getValue(), slp_runtime_alias_checks_max_scalar_cost_percent, Alloc); |
| 1004 | case OPT_slp_schedule_budget: |
| 1005 | return llvm::opt::parseArgValue(A.getValue(), slp_schedule_budget, Alloc); |
| 1006 | case OPT_slp_split_alternate_instructions: |
| 1007 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_split_alternate_instructions, Alloc); |
| 1008 | case OPT_slp_threshold: |
| 1009 | return llvm::opt::parseArgValue(A.getValue(), slp_threshold, Alloc); |
| 1010 | case OPT_slp_vec_loop_rt_checks_cost_percent: |
| 1011 | return llvm::opt::parseArgValue(A.getValue(), slp_vec_loop_rt_checks_cost_percent, Alloc); |
| 1012 | case OPT_slp_vectorize_hor_store: |
| 1013 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_hor_store, Alloc); |
| 1014 | case OPT_slp_vectorize_hor: |
| 1015 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_hor, Alloc); |
| 1016 | case OPT_slp_vectorize_loop_acc_rdx: |
| 1017 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_loop_acc_rdx, Alloc); |
| 1018 | case OPT_slp_vectorize_non_power_of_2: |
| 1019 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_non_power_of_2, Alloc); |
| 1020 | case OPT_slp_vectorize_once_used: |
| 1021 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_once_used, Alloc); |
| 1022 | case OPT_slp_vectorize_poor_throughput: |
| 1023 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_poor_throughput, Alloc); |
| 1024 | case OPT_slp_vectorize_with_runtime_alias_checks: |
| 1025 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , slp_vectorize_with_runtime_alias_checks, Alloc); |
| 1026 | case OPT_small_loop_cost: |
| 1027 | return llvm::opt::parseArgValue(A.getValue(), small_loop_cost, Alloc); |
| 1028 | case OPT_tail_folding_policy: |
| 1029 | return llvm::opt::parseArgValue(A.getValue(), tail_folding_policy, Alloc, [](llvm::StringRef V, auto &X) { |
| 1030 | if (V == "dont-fold-tail" ) { |
| 1031 | X = TailFoldingPolicyTy::None; |
| 1032 | return true; |
| 1033 | } |
| 1034 | if (V == "prefer-fold-tail" ) { |
| 1035 | X = TailFoldingPolicyTy::PreferFoldTail; |
| 1036 | return true; |
| 1037 | } |
| 1038 | if (V == "must-fold-tail" ) { |
| 1039 | X = TailFoldingPolicyTy::MustFoldTail; |
| 1040 | return true; |
| 1041 | } |
| 1042 | return false; |
| 1043 | }); |
| 1044 | case OPT_use_partial_reductions_by_default: |
| 1045 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , use_partial_reductions_by_default, Alloc); |
| 1046 | case OPT_vector_combine_max_scan_instrs: |
| 1047 | return llvm::opt::parseArgValue(A.getValue(), vector_combine_max_scan_instrs, Alloc); |
| 1048 | case OPT_vectorize_loops: |
| 1049 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vectorize_loops, Alloc); |
| 1050 | case OPT_vectorize_num_stores_pred: |
| 1051 | return llvm::opt::parseArgValue(A.getValue(), vectorize_num_stores_pred, Alloc); |
| 1052 | case OPT_vectorize_scev_check_threshold: |
| 1053 | return llvm::opt::parseArgValue(A.getValue(), vectorize_scev_check_threshold, Alloc); |
| 1054 | case OPT_vectorize_slp: |
| 1055 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vectorize_slp, Alloc); |
| 1056 | case OPT_vectorizer_consider_reg_pressure: |
| 1057 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vectorizer_consider_reg_pressure, Alloc); |
| 1058 | case OPT_vectorizer_maximize_bandwidth_for_vector_calls: |
| 1059 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vectorizer_maximize_bandwidth_for_vector_calls, Alloc); |
| 1060 | case OPT_vectorizer_maximize_bandwidth: |
| 1061 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vectorizer_maximize_bandwidth, Alloc); |
| 1062 | case OPT_vectorizer_min_trip_count: |
| 1063 | return llvm::opt::parseArgValue(A.getValue(), vectorizer_min_trip_count, Alloc); |
| 1064 | case OPT_view_slp_tree: |
| 1065 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , view_slp_tree, Alloc); |
| 1066 | case OPT_vplan_build_outerloop_stress_test: |
| 1067 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_build_outerloop_stress_test, Alloc); |
| 1068 | case OPT_vplan_outer_loop_legality_checks: |
| 1069 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_outer_loop_legality_checks, Alloc); |
| 1070 | #if !defined(NDEBUG) |
| 1071 | case OPT_vplan_print_after_all: |
| 1072 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_print_after_all, Alloc); |
| 1073 | #endif |
| 1074 | #if !defined(NDEBUG) |
| 1075 | case OPT_vplan_print_after: |
| 1076 | return llvm::opt::parseArgValue(A.getValue(), vplan_print_after, Alloc); |
| 1077 | #endif |
| 1078 | #if !defined(NDEBUG) |
| 1079 | case OPT_vplan_print_before_all: |
| 1080 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_print_before_all, Alloc); |
| 1081 | #endif |
| 1082 | #if !defined(NDEBUG) |
| 1083 | case OPT_vplan_print_before: |
| 1084 | return llvm::opt::parseArgValue(A.getValue(), vplan_print_before, Alloc); |
| 1085 | #endif |
| 1086 | case OPT_vplan_print_in_dot_format: |
| 1087 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_print_in_dot_format, Alloc); |
| 1088 | #if !defined(NDEBUG) |
| 1089 | case OPT_vplan_print_vector_region_scope: |
| 1090 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_print_vector_region_scope, Alloc); |
| 1091 | #endif |
| 1092 | case OPT_vplan_verify_each: |
| 1093 | return llvm::opt::parseArgValue(A.getNumValues() ? A.getValue() : "true" , vplan_verify_each, Alloc); |
| 1094 | } |
| 1095 | llvm_unreachable("option without a member" ); |
| 1096 | } |
| 1097 | #endif // OPTIONS_STRUCT_DEFS |
| 1098 | ///////// |
| 1099 | // ValuesCode |
| 1100 | |
| 1101 | #ifdef OPTTABLE_VALUES_CODE |
| 1102 | static llvm::StringRef getOptionValuesCode(unsigned ID) { |
| 1103 | switch (ID) { |
| 1104 | } |
| 1105 | return {}; |
| 1106 | } |
| 1107 | #undef OPTTABLE_VALUES_CODE |
| 1108 | #endif // OPTTABLE_VALUES_CODE |
| 1109 | ///////// |
| 1110 | // Groups |
| 1111 | |
| 1112 | #ifdef OPTION |
| 1113 | |
| 1114 | ////////// |
| 1115 | // Options |
| 1116 | |
| 1117 | OPTION(0, 6 /* <input> */, INPUT, Input, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0, 0, 0, 0) |
| 1118 | OPTION(0, 14 /* <unknown> */, UNKNOWN, Unknown, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 0, 0, 0, 0, 0) |
| 1119 | OPTION(1, 24 /* -disable-binop-extract-shuffle */, anonymous_115, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 55, 0, 0, 0, 0) |
| 1120 | OPTION(1, 99 /* -disable-loop-idiom-vectorize-all */, anonymous_0, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 133, 0, 0, 0, 0) |
| 1121 | OPTION(1, 167 /* -disable-loop-idiom-vectorize-bytecmp */, anonymous_1, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 205, 0, 0, 0, 0) |
| 1122 | OPTION(1, 285 /* -disable-loop-idiom-vectorize-find-first-byte */, anonymous_2, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 331, 0, 0, 0, 0) |
| 1123 | OPTION(1, 370 /* -disable-vector-combine */, anonymous_116, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 394, 0, 0, 0, 0) |
| 1124 | OPTION(1, 432 /* -enable-early-exit-vectorization-with-side-effects */, anonymous_21, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 483, 0, 0, 0, 0) |
| 1125 | OPTION(1, 564 /* -enable-early-exit-vectorization */, anonymous_20, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 597, 0, 0, 0, 0) |
| 1126 | OPTION(1, 661 /* -enable-epilogue-vectorization */, anonymous_22, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 692, 0, 0, 0, 0) |
| 1127 | OPTION(1, 731 /* -enable-histogram-loop-vectorization */, anonymous_6, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 768, 0, 0, 0, 0) |
| 1128 | OPTION(1, 830 /* -enable-if-conversion */, anonymous_7, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 852, 0, 0, 0, 0) |
| 1129 | OPTION(1, 894 /* -enable-ind-var-reg-heur */, anonymous_23, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 919, 0, 0, 0, 0) |
| 1130 | OPTION(1, 976 /* -enable-interleave-to-reduce-stalls */, anonymous_24, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1012, 0, 0, 0, 0) |
| 1131 | OPTION(1, 1127 /* -enable-interleaved-mem-accesses */, anonymous_25, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1160, 0, 0, 0, 0) |
| 1132 | OPTION(1, 1222 /* -enable-loadstore-runtime-interleave */, anonymous_26, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1259, 0, 0, 0, 0) |
| 1133 | OPTION(1, 1324 /* -enable-masked-interleaved-mem-accesses */, anonymous_27, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1364, 0, 0, 0, 0) |
| 1134 | OPTION(1, 1433 /* -enable-vplan-native-path */, anonymous_28, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1459, 0, 0, 0, 0) |
| 1135 | OPTION(1, 1540 /* -epilogue-tail-folding-policy */, anonymous_29, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1570, 0, 1635, 1669, 0) |
| 1136 | OPTION(1, 1701 /* -epilogue-vectorization-minimum-VF */, anonymous_30, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1736, 0, 0, 0, 0) |
| 1137 | OPTION(1, 1859 /* -force-ordered-reductions */, anonymous_31, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1885, 0, 0, 0, 0) |
| 1138 | OPTION(1, 1956 /* -force-partial-aliasing-vectorization */, anonymous_32, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 1994, 0, 0, 0, 0) |
| 1139 | OPTION(1, 2039 /* -force-tail-folding-style */, anonymous_33, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2065, 0, 2094, 2160, 0) |
| 1140 | OPTION(1, 2224 /* -force-target-instruction-cost */, anonymous_34, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2255, 0, 0, 0, 0) |
| 1141 | OPTION(1, 2396 /* -force-target-load-latency */, anonymous_35, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2423, 0, 0, 0, 0) |
| 1142 | OPTION(1, 2497 /* -force-target-max-scalar-interleave */, anonymous_36, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2533, 0, 0, 0, 0) |
| 1143 | OPTION(1, 2607 /* -force-target-max-vector-interleave */, anonymous_37, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2643, 0, 0, 0, 0) |
| 1144 | OPTION(1, 2721 /* -force-target-num-scalar-regs */, anonymous_38, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2751, 0, 0, 0, 0) |
| 1145 | OPTION(1, 2813 /* -force-target-num-vector-regs */, anonymous_39, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2843, 0, 0, 0, 0) |
| 1146 | OPTION(1, 2905 /* -force-target-supports-gather-scatter-ops */, anonymous_12, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 2947, 0, 0, 0, 0) |
| 1147 | OPTION(1, 3019 /* -force-target-supports-masked-memory-ops */, anonymous_13, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3060, 0, 0, 0, 0) |
| 1148 | OPTION(1, 3131 /* -force-target-supports-scalable-vectors */, anonymous_14, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3171, 0, 0, 0, 0) |
| 1149 | OPTION(1, 3300 /* -force-widen-divrem-via-masked-intrinsic */, anonymous_40, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3341, 0, 0, 0, 0) |
| 1150 | OPTION(1, 3412 /* -hints-allow-reordering */, anonymous_8, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3436, 0, 0, 0, 0) |
| 1151 | OPTION(1, 3508 /* -interleave-loops */, anonymous_41, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3526, 0, 0, 0, 0) |
| 1152 | OPTION(1, 3580 /* -loop-idiom-vectorize-bytecmp-vf */, anonymous_3, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3613, 0, 0, 0, 0) |
| 1153 | OPTION(1, 3664 /* -loop-idiom-vectorize-style */, anonymous_4, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3692, 0, 3741, 3761, 0) |
| 1154 | OPTION(1, 3779 /* -loop-idiom-vectorize-verify */, anonymous_5, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3808, 0, 0, 0, 0) |
| 1155 | OPTION(1, 3857 /* -loop-vectorize-with-block-frequency */, anonymous_42, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 3894, 0, 0, 0, 0) |
| 1156 | OPTION(1, 4046 /* -low-trip-count-loop-body-size-limit */, anonymous_43, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4083, 0, 0, 0, 0) |
| 1157 | OPTION(1, 4179 /* -lv-compressing-patterns */, anonymous_10, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4204, 0, 0, 0, 0) |
| 1158 | OPTION(1, 4247 /* -lv-strided-pointer-ivs */, anonymous_9, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4271, 0, 0, 0, 0) |
| 1159 | OPTION(1, 4342 /* -max-nested-scalar-reduction-interleave */, anonymous_44, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4382, 0, 0, 0, 0) |
| 1160 | OPTION(1, 4472 /* -pragma-vectorize-scev-check-threshold */, anonymous_45, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4511, 0, 0, 0, 0) |
| 1161 | OPTION(1, 4585 /* -prefer-inloop-reductions */, anonymous_15, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4611, 0, 0, 0, 0) |
| 1162 | OPTION(1, 4679 /* -prefer-predicated-reduction-select */, anonymous_46, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4715, 0, 0, 0, 0) |
| 1163 | OPTION(1, 4782 /* -sbvec-allow-files */, anonymous_68, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4801, 0, 0, 0, 0) |
| 1164 | OPTION(1, 4893 /* -sbvec-allow-non-pow2 */, anonymous_64, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4915, 0, 0, 0, 0) |
| 1165 | #if !defined(NDEBUG) |
| 1166 | OPTION(1, 4950 /* -sbvec-always-verify */, anonymous_61, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 4971, 0, 0, 0, 0) |
| 1167 | #endif |
| 1168 | OPTION(1, 5060 /* -sbvec-collect-seeds */, anonymous_65, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5081, 0, 0, 0, 0) |
| 1169 | OPTION(1, 5171 /* -sbvec-cost-threshold */, anonymous_67, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5193, 0, 0, 0, 0) |
| 1170 | OPTION(1, 5222 /* -sbvec-max-users-to-consider */, anonymous_73, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5251, 0, 0, 0, 0) |
| 1171 | OPTION(1, 5386 /* -sbvec-passes */, anonymous_69, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5400, 0, 0, 0, 0) |
| 1172 | OPTION(1, 5485 /* -sbvec-print-pass-pipeline */, anonymous_70, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5512, 0, 0, 0, 0) |
| 1173 | OPTION(1, 5549 /* -sbvec-seed-bundle-size-limit */, anonymous_71, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5579, 0, 0, 0, 0) |
| 1174 | OPTION(1, 5637 /* -sbvec-seed-groups-limit */, anonymous_72, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5662, 0, 0, 0, 0) |
| 1175 | OPTION(1, 5737 /* -sbvec-stop-at */, anonymous_62, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5752, 0, 0, 0, 0) |
| 1176 | OPTION(1, 5827 /* -sbvec-stop-bndl */, anonymous_63, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5844, 0, 0, 0, 0) |
| 1177 | OPTION(1, 5878 /* -sbvec-vec-reg-bits */, anonymous_66, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 5898, 0, 0, 0, 0) |
| 1178 | OPTION(1, 5982 /* -scalable-epilogue-vf-cost-scale-factor */, anonymous_16, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6022, 0, 0, 0, 0) |
| 1179 | OPTION(1, 6077 /* -scalable-vectorization */, anonymous_11, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6101, 0, 6213, 6239, 0) |
| 1180 | OPTION(1, 6263 /* -slp-copyable-elements */, anonymous_74, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6286, 0, 0, 0, 0) |
| 1181 | OPTION(1, 6366 /* -slp-cost-loop-trip-count */, anonymous_75, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6392, 0, 0, 0, 0) |
| 1182 | OPTION(1, 6501 /* -slp-disable-tree-reorder */, anonymous_76, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6527, 0, 0, 0, 0) |
| 1183 | OPTION(1, 6599 /* -slp-enable-masked-stores */, anonymous_77, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6625, 0, 0, 0, 0) |
| 1184 | OPTION(1, 6737 /* -slp-enable-strided-stores */, anonymous_78, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6764, 0, 0, 0, 0) |
| 1185 | OPTION(1, 6819 /* -slp-force-strided-loads */, anonymous_79, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6844, 0, 0, 0, 0) |
| 1186 | OPTION(1, 6922 /* -slp-inst-count-check */, anonymous_80, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 6944, 0, 0, 0, 0) |
| 1187 | OPTION(1, 7026 /* -slp-max-look-ahead-depth */, anonymous_81, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7052, 0, 0, 0, 0) |
| 1188 | OPTION(1, 7111 /* -slp-max-reg-size */, anonymous_82, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7129, 0, 0, 0, 0) |
| 1189 | OPTION(1, 7181 /* -slp-max-root-look-ahead-depth */, anonymous_83, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7212, 0, 0, 0, 0) |
| 1190 | OPTION(1, 7275 /* -slp-max-runtime-alias-checks */, anonymous_84, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7305, 0, 0, 0, 0) |
| 1191 | OPTION(1, 7398 /* -slp-max-stride */, anonymous_85, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7414, 0, 0, 0, 0) |
| 1192 | OPTION(1, 7462 /* -slp-max-vf */, anonymous_86, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7474, 0, 0, 0, 0) |
| 1193 | OPTION(1, 7521 /* -slp-min-reg-size */, anonymous_87, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7129, 0, 0, 0, 0) |
| 1194 | OPTION(1, 7539 /* -slp-min-strided-loads */, anonymous_88, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7562, 0, 0, 0, 0) |
| 1195 | OPTION(1, 7668 /* -slp-min-strided-stores */, anonymous_89, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7692, 0, 0, 0, 0) |
| 1196 | OPTION(1, 7799 /* -slp-min-tree-size */, anonymous_90, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7818, 0, 0, 0, 0) |
| 1197 | OPTION(1, 7876 /* -slp-non-vectorizables-as-reductions */, anonymous_91, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 7913, 0, 0, 0, 0) |
| 1198 | OPTION(1, 7977 /* -slp-per-lane-gather-scale */, anonymous_92, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8004, 0, 0, 0, 0) |
| 1199 | OPTION(1, 8115 /* -slp-phi-list-budget */, anonymous_93, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8136, 0, 0, 0, 0) |
| 1200 | OPTION(1, 8182 /* -slp-phi-vectorization-budget */, anonymous_94, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8212, 0, 0, 0, 0) |
| 1201 | OPTION(1, 8384 /* -slp-postprocess-stores-operands */, anonymous_95, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8417, 0, 0, 0, 0) |
| 1202 | OPTION(1, 8473 /* -slp-reassociate-ops */, anonymous_96, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8494, 0, 0, 0, 0) |
| 1203 | OPTION(1, 8553 /* -slp-reassociate-reorder-limit */, anonymous_97, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8584, 0, 0, 0, 0) |
| 1204 | OPTION(1, 8683 /* -slp-recursion-max-depth */, anonymous_98, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8708, 0, 0, 0, 0) |
| 1205 | OPTION(1, 8768 /* -slp-reduction-budget */, anonymous_99, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8790, 0, 0, 0, 0) |
| 1206 | OPTION(1, 8862 /* -slp-revec */, anonymous_100, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8873, 0, 0, 0, 0) |
| 1207 | OPTION(1, 8923 /* -slp-runtime-alias-checks-max-scalar-cost-percent */, anonymous_101, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 8973, 0, 0, 0, 0) |
| 1208 | OPTION(1, 9138 /* -slp-schedule-budget */, anonymous_102, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9159, 0, 0, 0, 0) |
| 1209 | OPTION(1, 9213 /* -slp-split-alternate-instructions */, anonymous_103, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9247, 0, 0, 0, 0) |
| 1210 | OPTION(1, 9308 /* -slp-threshold */, anonymous_104, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9323, 0, 0, 0, 0) |
| 1211 | OPTION(1, 9372 /* -slp-vec-loop-rt-checks-cost-percent */, anonymous_105, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9409, 0, 0, 0, 0) |
| 1212 | OPTION(1, 9560 /* -slp-vectorize-hor-store */, anonymous_107, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9585, 0, 0, 0, 0) |
| 1213 | OPTION(1, 9649 /* -slp-vectorize-hor */, anonymous_106, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9668, 0, 0, 0, 0) |
| 1214 | OPTION(1, 9711 /* -slp-vectorize-loop-acc-rdx */, anonymous_108, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9739, 0, 0, 0, 0) |
| 1215 | OPTION(1, 9848 /* -slp-vectorize-non-power-of-2 */, anonymous_109, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9878, 0, 0, 0, 0) |
| 1216 | OPTION(1, 9934 /* -slp-vectorize-once-used */, anonymous_110, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 9959, 0, 0, 0, 0) |
| 1217 | OPTION(1, 10031 /* -slp-vectorize-poor-throughput */, anonymous_111, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10062, 0, 0, 0, 0) |
| 1218 | OPTION(1, 10154 /* -slp-vectorize-with-runtime-alias-checks */, anonymous_112, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10195, 0, 0, 0, 0) |
| 1219 | OPTION(1, 10310 /* -small-loop-cost */, anonymous_47, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10327, 0, 0, 0, 0) |
| 1220 | OPTION(1, 10392 /* -tail-folding-policy */, anonymous_48, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10413, 0, 10469, 10518, 0) |
| 1221 | OPTION(1, 10565 /* -use-partial-reductions-by-default */, anonymous_119, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10600, 0, 0, 0, 0) |
| 1222 | OPTION(1, 10672 /* -vector-combine-max-scan-instrs */, anonymous_117, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10704, 0, 0, 0, 0) |
| 1223 | OPTION(1, 10760 /* -vectorize-loops */, anonymous_49, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10777, 0, 0, 0, 0) |
| 1224 | OPTION(1, 10811 /* -vectorize-num-stores-pred */, anonymous_50, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10838, 0, 0, 0, 0) |
| 1225 | OPTION(1, 10889 /* -vectorize-scev-check-threshold */, anonymous_51, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10921, 0, 0, 0, 0) |
| 1226 | OPTION(1, 10963 /* -vectorize-slp */, anonymous_113, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 10978, 0, 0, 0, 0) |
| 1227 | OPTION(1, 11011 /* -vectorizer-consider-reg-pressure */, anonymous_17, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11045, 0, 0, 0, 0) |
| 1228 | OPTION(1, 11096 /* -vectorizer-maximize-bandwidth-for-vector-calls */, anonymous_19, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11144, 0, 0, 0, 0) |
| 1229 | OPTION(1, 11200 /* -vectorizer-maximize-bandwidth */, anonymous_18, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11231, 0, 0, 0, 0) |
| 1230 | OPTION(1, 11340 /* -vectorizer-min-trip-count */, anonymous_52, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11367, 0, 0, 0, 0) |
| 1231 | OPTION(1, 11486 /* -view-slp-tree */, anonymous_114, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11501, 0, 0, 0, 0) |
| 1232 | OPTION(1, 11537 /* -vplan-build-outerloop-stress-test */, anonymous_53, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11572, 0, 0, 0, 0) |
| 1233 | OPTION(1, 11747 /* -vplan-outer-loop-legality-checks */, anonymous_54, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11781, 0, 0, 0, 0) |
| 1234 | #if !defined(NDEBUG) |
| 1235 | OPTION(1, 11904 /* -vplan-print-after-all */, anonymous_56, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11927, 0, 0, 0, 0) |
| 1236 | #endif |
| 1237 | #if !defined(NDEBUG) |
| 1238 | OPTION(1, 11972 /* -vplan-print-after */, anonymous_55, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 11991, 0, 0, 0, 0) |
| 1239 | #endif |
| 1240 | #if !defined(NDEBUG) |
| 1241 | OPTION(1, 12051 /* -vplan-print-before-all */, anonymous_58, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 12075, 0, 0, 0, 0) |
| 1242 | #endif |
| 1243 | #if !defined(NDEBUG) |
| 1244 | OPTION(1, 12121 /* -vplan-print-before */, anonymous_57, SeparateOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 12141, 0, 0, 0, 0) |
| 1245 | #endif |
| 1246 | OPTION(1, 12202 /* -vplan-print-in-dot-format */, anonymous_118, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 12229, 0, 0, 0, 0) |
| 1247 | #if !defined(NDEBUG) |
| 1248 | OPTION(1, 12286 /* -vplan-print-vector-region-scope */, anonymous_59, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 12319, 0, 0, 0, 0) |
| 1249 | #endif |
| 1250 | OPTION(1, 12407 /* -vplan-verify-each */, anonymous_60, FlagOrEq, INVALID, INVALID, 0, 0, static_cast<unsigned>(DefaultVis), 0, 12426, 0, 0, 0, 0) |
| 1251 | #endif // OPTION |
| 1252 | |
| 1253 | #ifdef SIMPLE_ENUM_VALUE_TABLE |
| 1254 | |
| 1255 | struct SimpleEnumValue { |
| 1256 | const char *Name; |
| 1257 | unsigned Value; |
| 1258 | }; |
| 1259 | |
| 1260 | struct SimpleEnumValueTable { |
| 1261 | const SimpleEnumValue *Table; |
| 1262 | unsigned Size; |
| 1263 | }; |
| 1264 | static const SimpleEnumValueTable SimpleEnumValueTables[] = {}; |
| 1265 | static const unsigned SimpleEnumValueTablesSize = std::size(SimpleEnumValueTables); |
| 1266 | #endif // SIMPLE_ENUM_VALUE_TABLE |
| 1267 | |