Lines Matching refs:niters
392 RGC belongs to loop LOOP. The loop originally iterated NITERS
402 NITERS * RGC->max_nscalars_per_iter * RGC->factor
411 (NITERS + NITERS_SKIP) * RGC->max_nscalars_per_iter * RGC->factor
426 rgroup_controls *rgc, tree niters,
446 tree nitems_total = niters;
686 loop. LOOP_VINFO describes the vectorization of LOOP. NITERS is
696 loop_vec_info loop_vinfo, tree niters,
706 tree orig_niters = niters;
708 /* Type of the initial value of NITERS. */
709 tree ni_actual_type = TREE_TYPE (niters);
713 /* Convert NITERS to the same size as the compare. */
721 niters = gimple_build (&preheader_seq, PLUS_EXPR, ni_actual_type,
722 niters, build_minus_one_cst (ni_actual_type));
723 niters = gimple_convert (&preheader_seq, compare_type, niters);
724 niters = gimple_build (&preheader_seq, PLUS_EXPR, compare_type,
725 niters, build_one_cst (compare_type));
728 niters = gimple_convert (&preheader_seq, compare_type, niters);
763 niters, niters_skip,
779 /* The loop iterates (NITERS - 1) / VF + 1 times.
783 tree niters_minus_one = fold_build2 (PLUS_EXPR, compare_type, niters,
801 vect_set_loop_condition_normal (class loop *loop, tree niters, tree step,
813 tree niters_type = TREE_TYPE (niters);
831 while (x < NITERS); */
834 limit = niters;
838 /* The following works for all values of NITERS except 0:
847 while (x <= NITERS - STEP);
849 so that the loop continues to iterate if x + STEP - 1 < NITERS
850 but stops if x + STEP - 1 >= NITERS.
852 However, if NITERS is zero, x never hits a value above NITERS - STEP
869 while (x < NITERS - STEP);
871 In both cases the loop limit is NITERS - STEP. */
873 limit = force_gimple_operand (niters, &seq, true, NULL_TREE);
909 if (limit == niters)
910 /* Case A: the loop iterates NITERS times. Subtract one to get the
912 loop->nb_iterations = fold_build2 (MINUS_EXPR, niters_type, niters,
915 /* Case B or C: the loop iterates (NITERS - STEP) / STEP + 1 times.
932 N == (NITERS - 1) / STEP + 1
934 times. When NITERS is zero, this is equivalent to making the loop
935 execute (1 << M) / STEP times, where M is the precision of NITERS.
940 N == (NITERS - STEP) / STEP + 1
942 times, where NITERS is known to be outside the range [1, STEP - 1].
943 This is equivalent to making the loop execute NITERS / STEP times
944 when NITERS is nonzero and (1 << M) / STEP times otherwise.
954 tree niters, tree step, tree final_iv,
963 niters, final_iv,
967 cond_stmt = vect_set_loop_condition_normal (loop, niters, step, final_iv,
1524 - NITERS - the number of iterations that LOOP executes (before it is
1552 tree niters, edge update_e)
1601 fold_convert (stype, niters), step_expr);
1771 "niters for prolog loop: %T\n", iters);
1793 If CODE is PLUS, the vector loop starts NITERS iterations after the
1794 scalar one, otherwise CODE is MINUS and the vector loop starts NITERS
1801 vect_update_init_of_dr (dr_vec_info *dr_info, tree niters, tree_code code)
1808 niters = fold_build2 (MULT_EXPR, sizetype,
1809 fold_convert (sizetype, niters),
1812 fold_convert (sizetype, offset), niters);
1820 CODE and NITERS are as for vect_update_inits_of_dr. */
1823 vect_update_inits_of_drs (loop_vec_info loop_vinfo, tree niters,
1832 /* Adjust niters to sizetype. We used to insert the stmts on loop preheader
1833 here, but since we might use these niters to update the epilogues niters
1836 if (!types_compatible_p (sizetype, TREE_TYPE (niters)))
1837 niters = fold_convert (sizetype, niters);
1844 vect_update_init_of_dr (dr_info, niters, code);
1910 var = create_tmp_var (TREE_TYPE (ni), "niters");
1940 tree niters = fold_build2 (PLUS_EXPR, type, niters_prolog,
1946 /* TH indicates the minimum niters of vectorized loop, while we
1947 niters of scalar loop. */
1967 build_int_cst (type, th), niters);
1970 return niters;
1973 /* NITERS is the number of times that the original scalar loop executes
1987 is true if NITERS doesn't overflow (i.e. if NITERS is always nonzero). */
1990 vect_gen_vector_loop_niters (loop_vec_info loop_vinfo, tree niters,
1995 tree niters_vector, step_vector, type = TREE_TYPE (niters);
2005 ni_minus_gap = fold_build2 (MINUS_EXPR, type, niters,
2017 ni_minus_gap = niters;
2023 /* Create: niters >> log2(vf) */
2024 /* If it's known that niters == number of latch executions + 1 doesn't
2025 overflow, we can generate niters >> log2(vf); otherwise we generate
2026 (niters - vf) >> log2(vf) + 1 by using the fact that we know ratio
2055 we set range information to make niters analyzer's life easier.
2513 - NITERS: The number of iterations of the loop.
2515 - NITERS_NO_OVERFLOW: No overflow in computing NITERS.
2516 - TH, CHECK_PROFITABILITY: Threshold of niters to vectorize loop if
2594 vect_do_peeling (loop_vec_info loop_vinfo, tree niters, tree nitersm1,
2601 tree type = TREE_TYPE (niters), guard_cond;
2745 /* Saving NITERs before the loop, as this may be changed by prologue. */
2782 vectorized loop. If true we should perform runtime checks on the NITERS
2882 /* Update niters for vector loop. */
2884 = fold_build2 (MINUS_EXPR, type, niters, niters_prolog);
2889 niters = vect_build_loop_niters (loop_vinfo, &new_var_p);
2893 set_range_info (niters, VR_RANGE,
2963 /* Build guard against NITERSM1 since NITERS may overflow. */
2993 /* If loop is peeled for non-zero constant times, now niters refers to
2997 vect_gen_vector_loop_niters (loop_vinfo, niters,
3022 niters, niters_vector_mult_vf);
3066 /* We now must calculate the number of NITERS performed by the previous
3068 tree niters = fold_build2 (PLUS_EXPR, TREE_TYPE (niters_vector_mult_vf),
3080 gphi *new_phi = create_phi_node (make_ssa_name (TREE_TYPE (niters)),
3082 tree new_ssa = make_ssa_name (TREE_TYPE (niters));
3083 gimple *stmt = gimple_build_assign (new_ssa, niters);
3097 niters = new_ssa;
3098 add_phi_arg (new_phi, niters, update_e, UNKNOWN_LOCATION);
3099 add_phi_arg (new_phi, build_zero_cst (TREE_TYPE (niters)), skip_e,
3101 niters = PHI_RESULT (new_phi);
3108 *advance = niters;
3114 tree epilogue_niters = fold_build2 (MINUS_EXPR, TREE_TYPE (niters),
3116 niters);
Indexes created Sun Jul 19 00:25:04 UTC 2026