* [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage @ 2015-11-20 9:24 Alan Hayward 2015-11-20 11:00 ` Richard Biener 0 siblings, 1 reply; 5+ messages in thread From: Alan Hayward @ 2015-11-20 9:24 UTC (permalink / raw) To: gcc-patches [-- Attachment #1: Type: text/plain, Size: 676 bytes --] When vectorising a integer induction condition reduction, is_nonwrapping_integer_induction ends up with different values for base during the analysis and build phases. In the first it is an INTEGER_CST, in the second the loop has been vectorised out and the base is now a variable. This results in the analysis and build stage detecting the STMT_VINFO_VEC_REDUCTION_TYPE as different types. The easiest way to fix this is to only check for integer induction conditions on the analysis stage. gcc/ PR tree-optimization/68413 * tree-vect-loop.c (vectorizable_reduction): Only check for integer cond reduction on analysis stage. Thanks, Alan. [-- Attachment #2: analysisonlycondcheck.patch --] [-- Type: application/octet-stream, Size: 2930 bytes --] diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-1.c b/gcc/testsuite/gcc.dg/vect/pr65947-1.c index 1e7a05dc8cc6f00fee265b9b8ad65beaa520f1e8..09fb6a5b446bac66e6509c704827231b10bec569 100644 --- a/gcc/testsuite/gcc.dg/vect/pr65947-1.c +++ b/gcc/testsuite/gcc.dg/vect/pr65947-1.c @@ -37,4 +37,4 @@ main (void) } /* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */ -/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" { xfail { ! vect_max_reduc } } } } */ +/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 2 "vect" { xfail { ! vect_max_reduc } } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr65947-4.c b/gcc/testsuite/gcc.dg/vect/pr65947-4.c index f4e7fdc97c89866b19838593cb84fc1754f87494..73ce780c08114b929f970afdc8d262efb8960562 100644 --- a/gcc/testsuite/gcc.dg/vect/pr65947-4.c +++ b/gcc/testsuite/gcc.dg/vect/pr65947-4.c @@ -37,5 +37,5 @@ main (void) } /* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 2 "vect" { xfail { ! vect_max_reduc } } } } */ -/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 4 "vect" { xfail { ! vect_max_reduc } } } } */ +/* { dg-final { scan-tree-dump-times "condition expression based on integer induction." 2 "vect" { xfail { ! vect_max_reduc } } } } */ diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 4630c86724e9f5df2b33eee4c60d3e7021b777b9..920dcd0ce5675753942d34db29c836e0e0737c26 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -5418,7 +5418,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, reduc_index = i; } - if (i == 1 && code == COND_EXPR && dt == vect_induction_def + if (!vec_stmt && i == 1 && code == COND_EXPR && dt == vect_induction_def && is_nonwrapping_integer_induction (def_stmt, loop)) { if (dump_enabled_p ()) @@ -5452,14 +5452,20 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, return false; } - gimple *tmp = vect_is_simple_reduction - (loop_vinfo, reduc_def_stmt, - !nested_cycle, &dummy, false, - &STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info)); + enum vect_reduction_type v_reduc_type; + gimple *tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt, + !nested_cycle, &dummy, false, + &v_reduc_type); - if (cond_expr_is_nonwrapping_integer_induction - && STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) == COND_REDUCTION) - STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = INTEGER_INDUC_COND_REDUCTION; + if (!vec_stmt) + { + if (cond_expr_is_nonwrapping_integer_induction + && v_reduc_type == COND_REDUCTION) + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) + = INTEGER_INDUC_COND_REDUCTION; + else + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = v_reduc_type; + } if (orig_stmt) gcc_assert (tmp == orig_stmt ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage 2015-11-20 9:24 [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage Alan Hayward @ 2015-11-20 11:00 ` Richard Biener 2015-11-20 12:44 ` Alan Hayward 0 siblings, 1 reply; 5+ messages in thread From: Richard Biener @ 2015-11-20 11:00 UTC (permalink / raw) To: Alan Hayward; +Cc: gcc-patches On Fri, Nov 20, 2015 at 10:24 AM, Alan Hayward <alan.hayward@arm.com> wrote: > When vectorising a integer induction condition reduction, > is_nonwrapping_integer_induction ends up with different values for base > during the analysis and build phases. In the first it is an INTEGER_CST, > in the second the loop has been vectorised out and the base is now a > variable. > > This results in the analysis and build stage detecting the > STMT_VINFO_VEC_REDUCTION_TYPE as different types. > > The easiest way to fix this is to only check for integer induction > conditions on the analysis stage. I don't like this. For the evolution part we have added STMT_VINFO_LOOP_PHI_EVOLUTION_PART. If you now need the original initial value as well then just save it. Or if you really want to go with the hack then please do not call is_nonwrapping_integer_induction with vec_stmt != NULL but initialize cond_expr_is_nonwrapping_integer_induction from STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) The hack also lacks a comment. Richard. > gcc/ > PR tree-optimization/68413 > * tree-vect-loop.c (vectorizable_reduction): Only check for > integer cond reduction on analysis stage. > > > > > Thanks, > Alan. > ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage 2015-11-20 11:00 ` Richard Biener @ 2015-11-20 12:44 ` Alan Hayward 2015-11-20 13:47 ` Richard Biener 0 siblings, 1 reply; 5+ messages in thread From: Alan Hayward @ 2015-11-20 12:44 UTC (permalink / raw) To: Richard Biener; +Cc: gcc-patches [-- Attachment #1: Type: text/plain, Size: 1532 bytes --] On 20/11/2015 11:00, "Richard Biener" <richard.guenther@gmail.com> wrote: >On Fri, Nov 20, 2015 at 10:24 AM, Alan Hayward <alan.hayward@arm.com> >wrote: >> When vectorising a integer induction condition reduction, >> is_nonwrapping_integer_induction ends up with different values for base >> during the analysis and build phases. In the first it is an INTEGER_CST, >> in the second the loop has been vectorised out and the base is now a >> variable. >> >> This results in the analysis and build stage detecting the >> STMT_VINFO_VEC_REDUCTION_TYPE as different types. >> >> The easiest way to fix this is to only check for integer induction >> conditions on the analysis stage. > >I don't like this. For the evolution part we have added >STMT_VINFO_LOOP_PHI_EVOLUTION_PART. If you now need >the original initial value as well then just save it. > >Or if you really want to go with the hack then please do not call >is_nonwrapping_integer_induction with vec_stmt != NULL but >initialize cond_expr_is_nonwrapping_integer_induction from >STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) > >The hack also lacks a comment. > Ok. I've gone for a combination of both: I now cache the base in STMT_VINFO_LOOP_PHI_EVOLUTION_BASE. I've removed the vec_stmt != NULL checks. I've moved the call to is_nonwrapping_integer_induction until after the vect_is_simple_reduction check. I never liked that I had is_nonwrapping_integer_induction early in the function, and think this looks better. Alan. [-- Attachment #2: analysisonlycondcheck2.patch --] [-- Type: application/octet-stream, Size: 5319 bytes --] diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 4630c86724e9f5df2b33eee4c60d3e7021b777b9..a2dfd2d07d1214949702b2ccffb7319c05901125 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -790,6 +790,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) dump_generic_expr (MSG_NOTE, TDF_SLIM, access_fn); dump_printf (MSG_NOTE, "\n"); } + STMT_VINFO_LOOP_PHI_EVOLUTION_BASE (stmt_vinfo) + = initial_condition_in_loop_num (access_fn, loop->num); STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) = evolution_part_in_loop_num (access_fn, loop->num); } @@ -803,6 +805,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) continue; } + gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_BASE (stmt_vinfo) != NULL_TREE); gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) != NULL_TREE); if (dump_enabled_p ()) @@ -5138,7 +5141,7 @@ static bool is_nonwrapping_integer_induction (gimple *stmt, struct loop *loop) { stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); - tree base = PHI_ARG_DEF_FROM_EDGE (stmt, loop_preheader_edge (loop)); + tree base = STMT_VINFO_LOOP_PHI_EVOLUTION_BASE (stmt_vinfo); tree step = STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo); tree lhs_type = TREE_TYPE (gimple_phi_result (stmt)); widest_int ni, max_loop_value, lhs_max; @@ -5273,7 +5276,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, tree def0, def1, tem, op0, op1 = NULL_TREE; bool first_p = true; tree cr_index_scalar_type = NULL_TREE, cr_index_vector_type = NULL_TREE; - bool cond_expr_is_nonwrapping_integer_induction = false; + gimple *cond_expr_induction_def_stmt = NULL; /* In case of reduction chain we switch to the first stmt in the chain, but we don't update STMT_INFO, since only the last stmt is marked as reduction @@ -5418,15 +5421,8 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, reduc_index = i; } - if (i == 1 && code == COND_EXPR && dt == vect_induction_def - && is_nonwrapping_integer_induction (def_stmt, loop)) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "condition expression based on integer " - "induction.\n"); - cond_expr_is_nonwrapping_integer_induction = true; - } + if (i == 1 && code == COND_EXPR && dt == vect_induction_def) + cond_expr_induction_def_stmt = def_stmt; } is_simple_use = vect_is_simple_use (ops[i], loop_vinfo, &def_stmt, &dt, &tem); @@ -5452,14 +5448,23 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, return false; } - gimple *tmp = vect_is_simple_reduction - (loop_vinfo, reduc_def_stmt, - !nested_cycle, &dummy, false, - &STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info)); + enum vect_reduction_type v_reduc_type; + gimple *tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt, + !nested_cycle, &dummy, false, + &v_reduc_type); - if (cond_expr_is_nonwrapping_integer_induction - && STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) == COND_REDUCTION) - STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = INTEGER_INDUC_COND_REDUCTION; + /* If we have a condition reduction, see if we can simplify it further. */ + if (v_reduc_type == COND_REDUCTION + && cond_expr_induction_def_stmt != NULL + && is_nonwrapping_integer_induction (cond_expr_induction_def_stmt, loop)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "condition expression based on integer induction.\n"); + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = INTEGER_INDUC_COND_REDUCTION; + } + else + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = v_reduc_type; if (orig_stmt) gcc_assert (tmp == orig_stmt diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 1b5c95c10f4d1f03f1a68abb1e862a8c708f75c7..b0c84d5e4ad5156ee3bafe9060ba5123e8a96f08 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -518,11 +518,12 @@ typedef struct _stmt_vec_info { tree dr_step; tree dr_aligned_to; - /* For loop PHI nodes, the evolution part of it. This makes sure + /* For loop PHI nodes, the base and evolution part of it. This makes sure this information is still available in vect_update_ivs_after_vectorizer where we may not be able to re-analyze the PHI nodes evolution as - peeling for the prologue loop can make it unanalyzable. The evolution - part is still correct though. */ + peeling for the prologue loop can make it unanalyzable. The base and + evolution parts are still correct though. */ + tree loop_phi_evolution_base; tree loop_phi_evolution_part; /* Used for various bookkeeping purposes, generally holding a pointer to @@ -645,6 +646,7 @@ STMT_VINFO_BB_VINFO (stmt_vec_info stmt_vinfo) #define STMT_VINFO_GROUP_GAP(S) (S)->gap #define STMT_VINFO_GROUP_SAME_DR_STMT(S) (S)->same_dr_stmt #define STMT_VINFO_GROUPED_ACCESS(S) ((S)->first_element != NULL && (S)->data_ref_info) +#define STMT_VINFO_LOOP_PHI_EVOLUTION_BASE(S) (S)->loop_phi_evolution_base #define STMT_VINFO_LOOP_PHI_EVOLUTION_PART(S) (S)->loop_phi_evolution_part #define STMT_VINFO_MIN_NEG_DIST(S) (S)->min_neg_dist ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage 2015-11-20 12:44 ` Alan Hayward @ 2015-11-20 13:47 ` Richard Biener 2015-11-20 14:21 ` Alan Hayward 0 siblings, 1 reply; 5+ messages in thread From: Richard Biener @ 2015-11-20 13:47 UTC (permalink / raw) To: Alan Hayward; +Cc: gcc-patches On Fri, Nov 20, 2015 at 1:33 PM, Alan Hayward <alan.hayward@arm.com> wrote: > > > On 20/11/2015 11:00, "Richard Biener" <richard.guenther@gmail.com> wrote: > >>On Fri, Nov 20, 2015 at 10:24 AM, Alan Hayward <alan.hayward@arm.com> >>wrote: >>> When vectorising a integer induction condition reduction, >>> is_nonwrapping_integer_induction ends up with different values for base >>> during the analysis and build phases. In the first it is an INTEGER_CST, >>> in the second the loop has been vectorised out and the base is now a >>> variable. >>> >>> This results in the analysis and build stage detecting the >>> STMT_VINFO_VEC_REDUCTION_TYPE as different types. >>> >>> The easiest way to fix this is to only check for integer induction >>> conditions on the analysis stage. >> >>I don't like this. For the evolution part we have added >>STMT_VINFO_LOOP_PHI_EVOLUTION_PART. If you now need >>the original initial value as well then just save it. >> >>Or if you really want to go with the hack then please do not call >>is_nonwrapping_integer_induction with vec_stmt != NULL but >>initialize cond_expr_is_nonwrapping_integer_induction from >>STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) >> >>The hack also lacks a comment. >> > > Ok. I've gone for a combination of both: > > I now cache the base in STMT_VINFO_LOOP_PHI_EVOLUTION_BASE. > > I've removed the vec_stmt != NULL checks. > > I've moved the call to is_nonwrapping_integer_induction until after the > vect_is_simple_reduction check. I never liked that I had > is_nonwrapping_integer_induction early in the function, and think this > looks better. It looks better but the comment for loop_phi_evolution_base is wrong. The value is _not_ "correct" after prologue peeling (unless you update it there to a non-constant expr). It is conservatively "correct" for is_nonwrapping_integer_induction though. Which is why I'd probably rename it to STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED to reflect this (and similar to STMT_VINFO_NITERS_UNCHANGED). Ok with that change. Thanks, Richard. > > Alan. > ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage 2015-11-20 13:47 ` Richard Biener @ 2015-11-20 14:21 ` Alan Hayward 0 siblings, 0 replies; 5+ messages in thread From: Alan Hayward @ 2015-11-20 14:21 UTC (permalink / raw) To: Richard Biener; +Cc: gcc-patches [-- Attachment #1: Type: text/plain, Size: 2246 bytes --] On 20/11/2015 13:47, "Richard Biener" <richard.guenther@gmail.com> wrote: >On Fri, Nov 20, 2015 at 1:33 PM, Alan Hayward <alan.hayward@arm.com> >wrote: >> >> >>On 20/11/2015 11:00, "Richard Biener" <richard.guenther@gmail.com> wrote: >> >>>On Fri, Nov 20, 2015 at 10:24 AM, Alan Hayward <alan.hayward@arm.com> >>>wrote: >>>>When vectorising a integer induction condition reduction, >>>>is_nonwrapping_integer_induction ends up with different values for base >>>>during the analysis and build phases. In the first it is an >>>>INTEGER_CST, >>>>in the second the loop has been vectorised out and the base is now a >>>>variable. >>>> >>>>This results in the analysis and build stage detecting the >>>>STMT_VINFO_VEC_REDUCTION_TYPE as different types. >>>> >>>>The easiest way to fix this is to only check for integer induction >>>>conditions on the analysis stage. >>> >>>I don't like this. For the evolution part we have added >>>STMT_VINFO_LOOP_PHI_EVOLUTION_PART. If you now need >>>the original initial value as well then just save it. >>> >>>Or if you really want to go with the hack then please do not call >>>is_nonwrapping_integer_induction with vec_stmt != NULL but >>>initialize cond_expr_is_nonwrapping_integer_induction from >>>STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) >>> >>>The hack also lacks a comment. >>> >> >>Ok. I've gone for a combination of both: >> >>I now cache the base in STMT_VINFO_LOOP_PHI_EVOLUTION_BASE. >> >>I've removed the vec_stmt != NULL checks. >> >>I've moved the call to is_nonwrapping_integer_induction until after the >>vect_is_simple_reduction check. I never liked that I had >>is_nonwrapping_integer_induction early in the function, and think this >>looks better. > >It looks better but the comment for loop_phi_evolution_base is wrong. >The value is _not_ "correct" after prologue peeling (unless you >update it there to a non-constant expr). It is conservatively "correct" >for is_nonwrapping_integer_induction though. Which is why I'd >probably rename it to STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED >to reflect this (and similar to STMT_VINFO_NITERS_UNCHANGED). > >Ok with that change. Updated as requested and submitted. Alan. [-- Attachment #2: analysisonlycondcheck3.patch --] [-- Type: application/octet-stream, Size: 5362 bytes --] diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 4630c86724e9f5df2b33eee4c60d3e7021b777b9..e4e77da1e1619c529783e806532751ba74448669 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -790,6 +790,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) dump_generic_expr (MSG_NOTE, TDF_SLIM, access_fn); dump_printf (MSG_NOTE, "\n"); } + STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (stmt_vinfo) + = initial_condition_in_loop_num (access_fn, loop->num); STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) = evolution_part_in_loop_num (access_fn, loop->num); } @@ -803,6 +805,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop) continue; } + gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (stmt_vinfo) + != NULL_TREE); gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) != NULL_TREE); if (dump_enabled_p ()) @@ -5138,7 +5142,7 @@ static bool is_nonwrapping_integer_induction (gimple *stmt, struct loop *loop) { stmt_vec_info stmt_vinfo = vinfo_for_stmt (stmt); - tree base = PHI_ARG_DEF_FROM_EDGE (stmt, loop_preheader_edge (loop)); + tree base = STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (stmt_vinfo); tree step = STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo); tree lhs_type = TREE_TYPE (gimple_phi_result (stmt)); widest_int ni, max_loop_value, lhs_max; @@ -5273,7 +5277,7 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, tree def0, def1, tem, op0, op1 = NULL_TREE; bool first_p = true; tree cr_index_scalar_type = NULL_TREE, cr_index_vector_type = NULL_TREE; - bool cond_expr_is_nonwrapping_integer_induction = false; + gimple *cond_expr_induction_def_stmt = NULL; /* In case of reduction chain we switch to the first stmt in the chain, but we don't update STMT_INFO, since only the last stmt is marked as reduction @@ -5418,15 +5422,8 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, reduc_index = i; } - if (i == 1 && code == COND_EXPR && dt == vect_induction_def - && is_nonwrapping_integer_induction (def_stmt, loop)) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "condition expression based on integer " - "induction.\n"); - cond_expr_is_nonwrapping_integer_induction = true; - } + if (i == 1 && code == COND_EXPR && dt == vect_induction_def) + cond_expr_induction_def_stmt = def_stmt; } is_simple_use = vect_is_simple_use (ops[i], loop_vinfo, &def_stmt, &dt, &tem); @@ -5452,14 +5449,23 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi, return false; } - gimple *tmp = vect_is_simple_reduction - (loop_vinfo, reduc_def_stmt, - !nested_cycle, &dummy, false, - &STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info)); + enum vect_reduction_type v_reduc_type; + gimple *tmp = vect_is_simple_reduction (loop_vinfo, reduc_def_stmt, + !nested_cycle, &dummy, false, + &v_reduc_type); - if (cond_expr_is_nonwrapping_integer_induction - && STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) == COND_REDUCTION) - STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = INTEGER_INDUC_COND_REDUCTION; + /* If we have a condition reduction, see if we can simplify it further. */ + if (v_reduc_type == COND_REDUCTION + && cond_expr_induction_def_stmt != NULL + && is_nonwrapping_integer_induction (cond_expr_induction_def_stmt, loop)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "condition expression based on integer induction.\n"); + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = INTEGER_INDUC_COND_REDUCTION; + } + else + STMT_VINFO_VEC_REDUCTION_TYPE (stmt_info) = v_reduc_type; if (orig_stmt) gcc_assert (tmp == orig_stmt diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 1b5c95c10f4d1f03f1a68abb1e862a8c708f75c7..b5ba3e63c5545d1d4d388b133f22674f1d44ba58 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -518,11 +518,13 @@ typedef struct _stmt_vec_info { tree dr_step; tree dr_aligned_to; - /* For loop PHI nodes, the evolution part of it. This makes sure + /* For loop PHI nodes, the base and evolution part of it. This makes sure this information is still available in vect_update_ivs_after_vectorizer where we may not be able to re-analyze the PHI nodes evolution as peeling for the prologue loop can make it unanalyzable. The evolution - part is still correct though. */ + part is still correct after peeling, but the base may have changed from + the version here. */ + tree loop_phi_evolution_base_unchanged; tree loop_phi_evolution_part; /* Used for various bookkeeping purposes, generally holding a pointer to @@ -645,6 +647,7 @@ STMT_VINFO_BB_VINFO (stmt_vec_info stmt_vinfo) #define STMT_VINFO_GROUP_GAP(S) (S)->gap #define STMT_VINFO_GROUP_SAME_DR_STMT(S) (S)->same_dr_stmt #define STMT_VINFO_GROUPED_ACCESS(S) ((S)->first_element != NULL && (S)->data_ref_info) +#define STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED(S) (S)->loop_phi_evolution_base_unchanged #define STMT_VINFO_LOOP_PHI_EVOLUTION_PART(S) (S)->loop_phi_evolution_part #define STMT_VINFO_MIN_NEG_DIST(S) (S)->min_neg_dist ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2015-11-20 14:21 UTC | newest] Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2015-11-20 9:24 [PATCH] PR tree-optimization/68413 : Only check for integer cond reduction on analysis stage Alan Hayward 2015-11-20 11:00 ` Richard Biener 2015-11-20 12:44 ` Alan Hayward 2015-11-20 13:47 ` Richard Biener 2015-11-20 14:21 ` Alan Hayward
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).