From: Dorit Nuzman <DORIT@il.ibm.com>
To: Zdenek Dvorak <rakdver@atrey.karlin.mff.cuni.cz>
Cc: gcc-patches@gcc.gnu.org
Subject: Re: [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 1/5
Date: Wed, 11 Apr 2007 11:51:00 -0000 [thread overview]
Message-ID: <OF7D25D99A.1098EA29-ONC22572B9.00714B0D-C22572BA.00413C43@il.ibm.com> (raw)
In-Reply-To: <20070402094812.GA12138@atrey.karlin.mff.cuni.cz>
[-- Attachment #1: Type: text/plain, Size: 2326 bytes --]
Zdenek Dvorak <rakdver@atrey.karlin.mff.cuni.cz> wrote on 02/04/2007
12:48:12:
> Hello,
>
> I will look at the patch. However, would it be possible to split it
> into smaller parts? The changes seem to be quite independent,
>
> Zdenek
>
> > This is exactly the same patch as was committed to autovect last week:
> > http://gcc.gnu.org/ml/gcc-patches/2007-03/msg01904.html
> > (but relative to mainline, and after testig on mainline).
> >
> > These are a few cleanups (really technical things, no new
functionality),
> > some of which will be also useful for outer-loop vectorization:
> >
...
> >
> > o Reorganize the calls to the vectorizable_* functions: In the drivers
that
> > call these functions (vect_analyze_operations and vect_transform_stmt),
we
> > currently call most of these functions only for RELEVANT_P stmts, and
then
> > call vectorizable_reduction only for LIVE_P stmts. Now, instead, each
of
> > the vectorizable_* functions checks that STMT_VINFO_RELEVANT/LIVE_P are
as
> > expected, and in the two driver functions we don't check for
> > STMT_VINFO_RELEVANT_P anymore, but apply the vectorizable_* functions
to
> > all stmts. When looking at outer-loops this is useful because a
reduction
> > (in the inner-loop) may now be marked RELEVANT (if it is used in the
> > outer-loop), and not only LIVE as it is currently.
> >
Tested on the vectorizer testcases
Bootstrapped and passed full testing on powerpc-linux together with the
other parts of this patch.
thanks,
dorit
ChangeLog:
* tree-vect-analyze.c (vect_analyze_operations): Reorganize calls to
vectorizable_* functions.
* tree-vect-transform.c (vectorizable_call): Add check for
STMT_VINFO_RELEVANT_P, STMT_VINFO_DEF_TYPE and STMT_VINFO_LIVE_P.
(vectorizable_store): likewise.
(vectorizable_conversion): Add check for STMT_VINFO_DEF_TYPE.
Add comments.
(vectorizable_operation, vectorizable_type_demotion): Likewise.
(vectorizable_type_promotion, vectorizable_load): Likewise.
(vectorizable_live_operation, vectorizable_condition): Likewise.
(vectorizable_assignment): Add check for STMT_VINFO_DEF_TYPE and
STMT_VINFO_LIVE_P.
(vect_transform_stmt): Reorganize calls to vectorizable_* functions.
Patch:
(See attached file: vect_cleanups.1.reorg.txt)
[-- Attachment #2: vect_cleanups.1.reorg.txt --]
[-- Type: text/plain, Size: 21457 bytes --]
Index: tree-vect-analyze.c
===================================================================
*** tree-vect-analyze.c (revision 123694)
--- tree-vect-analyze.c (working copy)
*************** vect_analyze_operations (loop_vec_info l
*** 325,332 ****
/* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
fprintf (vect_dump, "not vectorized: value used after loop.");
! return false;
! }
if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_loop
&& STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
--- 325,332 ----
/* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
fprintf (vect_dump, "not vectorized: value used after loop.");
! return false;
! }
if (STMT_VINFO_RELEVANT (stmt_info) == vect_used_in_loop
&& STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
*************** vect_analyze_operations (loop_vec_info l
*** 337,348 ****
--- 337,352 ----
fprintf (vect_dump, "not vectorized: unsupported pattern.");
return false;
}
+
+ if (STMT_VINFO_RELEVANT_P (stmt_info))
+ need_to_vectorize = true;
}
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{
tree stmt = bsi_stmt (si);
stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+ enum vect_def_type relevance = STMT_VINFO_RELEVANT (stmt_info);
if (vect_print_dump_info (REPORT_DETAILS))
{
*************** vect_analyze_operations (loop_vec_info l
*** 367,421 ****
continue;
}
! if (STMT_VINFO_RELEVANT_P (stmt_info))
! {
! gcc_assert (GIMPLE_STMT_P (stmt)
! || !VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))));
! gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
!
! ok = (vectorizable_type_promotion (stmt, NULL, NULL)
! || vectorizable_type_demotion (stmt, NULL, NULL)
! || vectorizable_conversion (stmt, NULL, NULL)
! || vectorizable_operation (stmt, NULL, NULL)
! || vectorizable_assignment (stmt, NULL, NULL)
! || vectorizable_load (stmt, NULL, NULL)
! || vectorizable_call (stmt, NULL, NULL)
! || vectorizable_store (stmt, NULL, NULL)
! || vectorizable_condition (stmt, NULL, NULL));
!
! if (!ok)
! {
! if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
! {
! fprintf (vect_dump,
! "not vectorized: relevant stmt not supported: ");
! print_generic_expr (vect_dump, stmt, TDF_SLIM);
! }
! return false;
! }
! need_to_vectorize = true;
! }
! if (STMT_VINFO_LIVE_P (stmt_info))
{
! ok = vectorizable_reduction (stmt, NULL, NULL);
! if (ok)
! need_to_vectorize = true;
! else
! ok = vectorizable_live_operation (stmt, NULL, NULL);
! if (!ok)
{
! if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
! {
! fprintf (vect_dump,
! "not vectorized: live stmt not supported: ");
! print_generic_expr (vect_dump, stmt, TDF_SLIM);
! }
! return false;
}
! }
} /* stmts in bb */
} /* bbs */
--- 371,427 ----
continue;
}
! switch (STMT_VINFO_DEF_TYPE (stmt_info))
! {
! case vect_loop_def:
! break;
!
! case vect_reduction_def:
! gcc_assert (relevance == vect_unused_in_loop);
! break;
!
! case vect_induction_def:
! case vect_constant_def:
! case vect_invariant_def:
! case vect_unknown_def_type:
! default:
! gcc_unreachable ();
! }
! if (STMT_VINFO_RELEVANT_P (stmt_info))
{
! gcc_assert (GIMPLE_STMT_P (stmt)
! || !VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))));
! gcc_assert (STMT_VINFO_VECTYPE (stmt_info));
! need_to_vectorize = true;
! }
! ok = (vectorizable_type_promotion (stmt, NULL, NULL)
! || vectorizable_type_demotion (stmt, NULL, NULL)
! || vectorizable_conversion (stmt, NULL, NULL)
! || vectorizable_operation (stmt, NULL, NULL)
! || vectorizable_assignment (stmt, NULL, NULL)
! || vectorizable_load (stmt, NULL, NULL)
! || vectorizable_call (stmt, NULL, NULL)
! || vectorizable_store (stmt, NULL, NULL)
! || vectorizable_condition (stmt, NULL, NULL)
! || vectorizable_reduction (stmt, NULL, NULL));
!
! /* Stmts that are (also) "live" (i.e. - that are used out of the loop)
! need extra handling, except for vectorizable reductions. */
! if (STMT_VINFO_LIVE_P (stmt_info)
! && STMT_VINFO_TYPE (stmt_info) != reduc_vec_info_type)
! ok |= vectorizable_live_operation (stmt, NULL, NULL);
! if (!ok)
! {
! if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
{
! fprintf (vect_dump, "not vectorized: stmt not supported: ");
! print_generic_expr (vect_dump, stmt, TDF_SLIM);
}
! return false;
! }
} /* stmts in bb */
} /* bbs */
Index: tree-vect-transform.c
===================================================================
*** tree-vect-transform.c (revision 123694)
--- tree-vect-transform.c (working copy)
*************** vectorizable_call (tree stmt, block_stmt
*** 1816,1821 ****
--- 1816,1835 ----
int ncopies, j, nargs;
call_expr_arg_iterator iter;
+ if (!STMT_VINFO_RELEVANT_P (stmt_info))
+ return false;
+
+ if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
+ return false;
+
+ /* FORNOW: not yet supported. */
+ if (STMT_VINFO_LIVE_P (stmt_info))
+ {
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "value used after loop.");
+ return false;
+ }
+
/* Is STMT a vectorizable call? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_conversion (tree stmt, bloc
*** 1994,2000 ****
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (STMT_VINFO_LIVE_P (stmt_info))
{
--- 2008,2015 ----
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
if (STMT_VINFO_LIVE_P (stmt_info))
{
*************** vectorizable_assignment (tree stmt, bloc
*** 2134,2145 ****
if (ncopies > 1)
return false; /* FORNOW */
- /* Is vectorizable assignment? */
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 2149,2169 ----
if (ncopies > 1)
return false; /* FORNOW */
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
!
! /* FORNOW: not yet supported. */
! if (STMT_VINFO_LIVE_P (stmt_info))
! {
! if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "value used after loop.");
! return false;
! }
+ /* Is vectorizable assignment? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_operation (tree stmt, block
*** 2246,2265 ****
gcc_assert (ncopies >= 1);
- /* Is STMT a vectorizable binary/unary operation? */
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (STMT_VINFO_LIVE_P (stmt_info))
{
- /* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 2270,2290 ----
gcc_assert (ncopies >= 1);
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
+ /* FORNOW: not yet supported. */
if (STMT_VINFO_LIVE_P (stmt_info))
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
+ /* Is STMT a vectorizable binary/unary operation? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_type_demotion (tree stmt, b
*** 2514,2534 ****
optab optab;
enum machine_mode vec_mode;
- /* Is STMT a vectorizable type-demotion operation? */
-
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
!
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
!
if (STMT_VINFO_LIVE_P (stmt_info))
{
- /* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 2539,2559 ----
optab optab;
enum machine_mode vec_mode;
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
!
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
!
! /* FORNOW: not yet supported. */
if (STMT_VINFO_LIVE_P (stmt_info))
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
+ /* Is STMT a vectorizable type-demotion operation? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_type_promotion (tree stmt,
*** 2723,2743 ****
int j;
tree vectype_in;
- /* Is STMT a vectorizable type-promotion operation? */
-
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (STMT_VINFO_LIVE_P (stmt_info))
{
- /* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "value used after loop.");
return false;
}
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 2748,2768 ----
int j;
tree vectype_in;
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
+ /* FORNOW: not yet supported. */
if (STMT_VINFO_LIVE_P (stmt_info))
{
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "value used after loop.");
return false;
}
+ /* Is STMT a vectorizable type-promotion operation? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_store (tree stmt, block_stm
*** 3064,3069 ****
--- 3089,3107 ----
VEC(tree,heap) *dr_chain = NULL, *oprnds = NULL, *result_chain = NULL;
gcc_assert (ncopies >= 1);
+ if (!STMT_VINFO_RELEVANT_P (stmt_info))
+ return false;
+
+ if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
+ return false;
+
+ if (STMT_VINFO_LIVE_P (stmt_info))
+ {
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "value used after loop.");
+ return false;
+ }
+
/* Is vectorizable store? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
*************** vectorizable_load (tree stmt, block_stmt
*** 3710,3729 ****
bool strided_load = false;
tree first_stmt;
- /* Is vectorizable load? */
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (STMT_VINFO_LIVE_P (stmt_info))
{
- /* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 3748,3768 ----
bool strided_load = false;
tree first_stmt;
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
+ /* FORNOW: not yet supported. */
if (STMT_VINFO_LIVE_P (stmt_info))
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
+ /* Is vectorizable load? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vectorizable_live_operation (tree stmt,
*** 4010,4016 ****
tree def, def_stmt;
enum vect_def_type dt;
! if (!STMT_VINFO_LIVE_P (stmt_info))
return false;
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
--- 4049,4057 ----
tree def, def_stmt;
enum vect_def_type dt;
! gcc_assert (STMT_VINFO_LIVE_P (stmt_info));
!
! if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
return false;
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
*************** vectorizable_condition (tree stmt, block
*** 4123,4138 ****
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! gcc_assert (STMT_VINFO_DEF_TYPE (stmt_info) == vect_loop_def);
if (STMT_VINFO_LIVE_P (stmt_info))
{
- /* FORNOW: not yet supported. */
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
--- 4164,4181 ----
if (!STMT_VINFO_RELEVANT_P (stmt_info))
return false;
! if (STMT_VINFO_DEF_TYPE (stmt_info) != vect_loop_def)
! return false;
+ /* FORNOW: not yet supported. */
if (STMT_VINFO_LIVE_P (stmt_info))
{
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "value used after loop.");
return false;
}
+ /* Is vectorizable conditional operation? */
if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
return false;
*************** vect_transform_stmt (tree stmt, block_st
*** 4225,4336 ****
tree orig_stmt_in_pattern;
bool done;
! if (STMT_VINFO_RELEVANT_P (stmt_info))
{
! switch (STMT_VINFO_TYPE (stmt_info))
! {
! case type_demotion_vec_info_type:
! done = vectorizable_type_demotion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case type_promotion_vec_info_type:
! done = vectorizable_type_promotion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case type_conversion_vec_info_type:
! done = vectorizable_conversion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case op_vec_info_type:
! done = vectorizable_operation (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case assignment_vec_info_type:
! done = vectorizable_assignment (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case load_vec_info_type:
! done = vectorizable_load (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case store_vec_info_type:
! done = vectorizable_store (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! if (DR_GROUP_FIRST_DR (stmt_info))
! {
! /* In case of interleaving, the whole chain is vectorized when the
! last store in the chain is reached. Store stmts before the last
! one are skipped, and there vec_stmt_info shouldn't be freed
! meanwhile. */
! *strided_store = true;
! if (STMT_VINFO_VEC_STMT (stmt_info))
! is_store = true;
}
! else
! is_store = true;
! break;
! case condition_vec_info_type:
! done = vectorizable_condition (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
! case call_vec_info_type:
! done = vectorizable_call (stmt, bsi, &vec_stmt);
! break;
! default:
! if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "stmt not supported.");
! gcc_unreachable ();
! }
! gcc_assert (vec_stmt || *strided_store);
! if (vec_stmt)
{
! STMT_VINFO_VEC_STMT (stmt_info) = vec_stmt;
! orig_stmt_in_pattern = STMT_VINFO_RELATED_STMT (stmt_info);
! if (orig_stmt_in_pattern)
{
! stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt_in_pattern);
! if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
! {
! gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
!
! /* STMT was inserted by the vectorizer to replace a
! computation idiom. ORIG_STMT_IN_PATTERN is a stmt in the
! original sequence that computed this idiom. We need to
! record a pointer to VEC_STMT in the stmt_info of
! ORIG_STMT_IN_PATTERN. See more details in the
! documentation of vect_pattern_recog. */
!
! STMT_VINFO_VEC_STMT (stmt_vinfo) = vec_stmt;
! }
}
}
}
- if (STMT_VINFO_LIVE_P (stmt_info))
- {
- switch (STMT_VINFO_TYPE (stmt_info))
- {
- case reduc_vec_info_type:
- done = vectorizable_reduction (stmt, bsi, &vec_stmt);
- gcc_assert (done);
- break;
-
- default:
- done = vectorizable_live_operation (stmt, bsi, &vec_stmt);
- gcc_assert (done);
- }
- }
-
return is_store;
}
--- 4268,4372 ----
tree orig_stmt_in_pattern;
bool done;
! switch (STMT_VINFO_TYPE (stmt_info))
{
! case type_demotion_vec_info_type:
! done = vectorizable_type_demotion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case type_promotion_vec_info_type:
! done = vectorizable_type_promotion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case type_conversion_vec_info_type:
! done = vectorizable_conversion (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case op_vec_info_type:
! done = vectorizable_operation (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case assignment_vec_info_type:
! done = vectorizable_assignment (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case load_vec_info_type:
! done = vectorizable_load (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case store_vec_info_type:
! done = vectorizable_store (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! if (DR_GROUP_FIRST_DR (stmt_info))
! {
! /* In case of interleaving, the whole chain is vectorized when the
! last store in the chain is reached. Store stmts before the last
! one are skipped, and there vec_stmt_info shouldn't be freed
! meanwhile. */
! *strided_store = true;
! if (STMT_VINFO_VEC_STMT (stmt_info))
! is_store = true;
}
! else
! is_store = true;
! break;
! case condition_vec_info_type:
! done = vectorizable_condition (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
!
! case call_vec_info_type:
! done = vectorizable_call (stmt, bsi, &vec_stmt);
! break;
!
! case reduc_vec_info_type:
! done = vectorizable_reduction (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! break;
! default:
! if (!STMT_VINFO_LIVE_P (stmt_info))
! {
! if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "stmt not supported.");
! gcc_unreachable ();
! }
! }
! if (STMT_VINFO_LIVE_P (stmt_info)
! && STMT_VINFO_TYPE (stmt_info) != reduc_vec_info_type)
! {
! done = vectorizable_live_operation (stmt, bsi, &vec_stmt);
! gcc_assert (done);
! }
! if (vec_stmt)
! {
! STMT_VINFO_VEC_STMT (stmt_info) = vec_stmt;
! orig_stmt_in_pattern = STMT_VINFO_RELATED_STMT (stmt_info);
! if (orig_stmt_in_pattern)
{
! stmt_vec_info stmt_vinfo = vinfo_for_stmt (orig_stmt_in_pattern);
! /* STMT was inserted by the vectorizer to replace a computation idiom.
! ORIG_STMT_IN_PATTERN is a stmt in the original sequence that
! computed this idiom. We need to record a pointer to VEC_STMT in
! the stmt_info of ORIG_STMT_IN_PATTERN. See more details in the
! documentation of vect_pattern_recog. */
! if (STMT_VINFO_IN_PATTERN_P (stmt_vinfo))
{
! gcc_assert (STMT_VINFO_RELATED_STMT (stmt_vinfo) == stmt);
! STMT_VINFO_VEC_STMT (stmt_vinfo) = vec_stmt;
}
}
}
return is_store;
}
next prev parent reply other threads:[~2007-04-11 11:51 UTC|newest]
Thread overview: 19+ messages / expand[flat|nested] mbox.gz Atom feed top
2007-04-02 8:43 [patch] vectorizer cleanups (and prep for outer-loop vectorization) Dorit Nuzman
2007-04-02 9:48 ` Zdenek Dvorak
2007-04-02 9:55 ` Zdenek Dvorak
2007-04-11 11:51 ` [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 4/5 Dorit Nuzman
2007-04-12 12:17 ` Zdenek Dvorak
2007-04-11 11:51 ` [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 3/5 Dorit Nuzman
2007-04-12 12:11 ` Zdenek Dvorak
2007-04-14 18:54 ` Dorit Nuzman
2007-04-14 19:32 ` Zdenek Dvorak
2007-04-11 11:51 ` Dorit Nuzman [this message]
2007-04-11 11:51 ` [patch] vectorizer cleanups (and prep for outer-loop vectorization) Dorit Nuzman
2007-04-11 11:51 ` [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 5/5 Dorit Nuzman
2007-04-12 12:22 ` Zdenek Dvorak
2007-04-12 14:23 ` Daniel Berlin
2007-04-11 11:51 ` [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 2/5 Dorit Nuzman
2007-04-11 23:53 ` Zdenek Dvorak
2007-04-14 18:29 ` Dorit Nuzman
2007-04-14 18:56 ` Zdenek Dvorak
2007-04-11 23:32 [patch] vectorizer cleanups (and prep for outer-loop vectorization) - part 1/5 Zdenek Dvorak
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=OF7D25D99A.1098EA29-ONC22572B9.00714B0D-C22572BA.00413C43@il.ibm.com \
--to=dorit@il.ibm.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=rakdver@atrey.karlin.mff.cuni.cz \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).