* [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).