OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tree-vectorizer.h (is_pattern_stmt_p): New. 

* tree-vectorizer.h (is_pattern_stmt_p): New.
        * tree-vect-analyze.c (vect_determine_vectorization_factor): Fix
        formatting (tabs instead of spaces). Cleanup and clarify setting
        of STMT_VINFO_VECTYPE. Call is_pattern_stmt_p.
        * tree-vect-transform.c (vect_get_vec_def_for_operand): Fix typo.
        (vectorizable_type_demotion): Check that types are integral.
        (vectorizable_type_promotion): Likewise.
        (vectorizable_store): Fix typo.  Eliminate new-line at end of
        comments.


Co-Authored-By: Tehila Meyzels <tehila@il.ibm.com>

From-SVN: r120825
This commit is contained in:
Dorit Nuzman 2007-01-16 08:26:03 +00:00 committed by Dorit Nuzman
parent 03b1d1341c
commit 878aa81717
4 changed files with 100 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
gcc/ChangeLog
View File

@ -1,3 +1,16 @@
2007-01-16 Dorit Nuzman <dorit@il.ibm.com>
Tehila Meyzels <tehila@il.ibm.com>
* tree-vectorizer.h (is_pattern_stmt_p): New.
* tree-vect-analyze.c (vect_determine_vectorization_factor): Fix
formatting (tabs instead of spaces). Cleanup and clarify setting
of STMT_VINFO_VECTYPE. Call is_pattern_stmt_p.
* tree-vect-transform.c (vect_get_vec_def_for_operand): Fix typo.
(vectorizable_type_demotion): Check that types are integral.
(vectorizable_type_promotion): Likewise.
(vectorizable_store): Fix typo. Eliminate new-line at end of
comments.
2007-01-16 Jan Hubicka <jh@suse.cz> 2007-01-16 Jan Hubicka <jh@suse.cz>
* tree-ssanames.c (release_dead_ssa_names): Remove invalidated * tree-ssanames.c (release_dead_ssa_names): Remove invalidated

101
gcc/tree-vect-analyze.c
View File

@ -109,52 +109,67 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
{ {
tree stmt = bsi_stmt (si); tree stmt = bsi_stmt (si);
unsigned int nunits; unsigned int nunits;
stmt_vec_info stmt_info = vinfo_for_stmt (stmt); stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
tree vectype; tree vectype;
if (vect_print_dump_info (REPORT_DETAILS)) if (vect_print_dump_info (REPORT_DETAILS))
{ {
fprintf (vect_dump, "==> examining statement: "); fprintf (vect_dump, "==> examining statement: ");
print_generic_expr (vect_dump, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
gcc_assert (stmt_info); if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
/* skip stmts which do not need to be vectorized. */ continue;
if (!STMT_VINFO_RELEVANT_P (stmt_info)
gcc_assert (stmt_info);
/* skip stmts which do not need to be vectorized. */
if (!STMT_VINFO_RELEVANT_P (stmt_info)
&& !STMT_VINFO_LIVE_P (stmt_info)) && !STMT_VINFO_LIVE_P (stmt_info))
{ {
if (vect_print_dump_info (REPORT_DETAILS)) if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "skip."); fprintf (vect_dump, "skip.");
continue; continue;
} }
if (!GIMPLE_STMT_P (stmt) if (!GIMPLE_STMT_P (stmt)
&& VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt)))) && VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
{ {
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS))
{ {
fprintf (vect_dump, "not vectorized: vector stmt in loop:"); fprintf (vect_dump, "not vectorized: vector stmt in loop:");
print_generic_expr (vect_dump, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
if (STMT_VINFO_VECTYPE (stmt_info)) if (STMT_VINFO_VECTYPE (stmt_info))
{ {
/* The only case when a vectype had been already set is for stmts
that contain a dataref, or for "pattern-stmts" (stmts generated
by the vectorizer to represent/replace a certain idiom). */
gcc_assert (STMT_VINFO_DATA_REF (stmt_info)
|| is_pattern_stmt_p (stmt_info));
vectype = STMT_VINFO_VECTYPE (stmt_info); vectype = STMT_VINFO_VECTYPE (stmt_info);
scalar_type = TREE_TYPE (vectype);
} }
else else
{ {
if (STMT_VINFO_DATA_REF (stmt_info)) gcc_assert (! STMT_VINFO_DATA_REF (stmt_info)
scalar_type = && !is_pattern_stmt_p (stmt_info));
TREE_TYPE (DR_REF (STMT_VINFO_DATA_REF (stmt_info)));
else if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) /* We set the vectype according to the type of the result (lhs).
scalar_type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 0)); For stmts whose result-type is different than the type of the
else arguments (e.g. demotion, promotion), vectype will be reset
scalar_type = TREE_TYPE (stmt); appropriately (later). Note that we have to visit the smallest
datatype in this function, because that determines the VF.
If the samallest datatype in the loop is present only as the
rhs of a promotion operation - we'd miss it here.
However, in such a case, that a variable of this datatype
does not appear in the lhs anywhere in the loop, it shouldn't
affect the vectorization factor. */
scalar_type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 0));
if (vect_print_dump_info (REPORT_DETAILS)) if (vect_print_dump_info (REPORT_DETAILS))
{ {
@ -176,17 +191,17 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
STMT_VINFO_VECTYPE (stmt_info) = vectype; STMT_VINFO_VECTYPE (stmt_info) = vectype;
} }
if (vect_print_dump_info (REPORT_DETAILS)) if (vect_print_dump_info (REPORT_DETAILS))
{ {
fprintf (vect_dump, "vectype: "); fprintf (vect_dump, "vectype: ");
print_generic_expr (vect_dump, vectype, TDF_SLIM); print_generic_expr (vect_dump, vectype, TDF_SLIM);
} }
nunits = TYPE_VECTOR_SUBPARTS (vectype); nunits = TYPE_VECTOR_SUBPARTS (vectype);
if (vect_print_dump_info (REPORT_DETAILS)) if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "nunits = %d", nunits); fprintf (vect_dump, "nunits = %d", nunits);
if (!vectorization_factor if (!vectorization_factor
|| (nunits > vectorization_factor)) || (nunits > vectorization_factor))
vectorization_factor = nunits; vectorization_factor = nunits;

23
gcc/tree-vect-transform.c
View File

@ -665,7 +665,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt, tree *scalar_def)
vector stmt (each computing a vector of 'nunits' results, and together vector stmt (each computing a vector of 'nunits' results, and together
computing 'VF' results in each iteration). This function is called when computing 'VF' results in each iteration). This function is called when
vectorizing such a stmt (e.g. vectorizing S2 in the illustration below, in vectorizing such a stmt (e.g. vectorizing S2 in the illustration below, in
which VF=16 and nuniti=4, so the number of copies required is 4): which VF=16 and nunits=4, so the number of copies required is 4):
scalar stmt: vectorized into: STMT_VINFO_RELATED_STMT scalar stmt: vectorized into: STMT_VINFO_RELATED_STMT
@ -2171,6 +2171,10 @@ vectorizable_type_demotion (tree stmt, block_stmt_iterator *bsi,
ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out; ncopies = LOOP_VINFO_VECT_FACTOR (loop_vinfo) / nunits_out;
gcc_assert (ncopies >= 1); gcc_assert (ncopies >= 1);
if (! INTEGRAL_TYPE_P (scalar_type)
|| !INTEGRAL_TYPE_P (TREE_TYPE (op0)))
return false;
/* Check the operands of the operation. */ /* Check the operands of the operation. */
if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt0)) if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt0))
@ -2377,6 +2381,10 @@ vectorizable_type_promotion (tree stmt, block_stmt_iterator *bsi,
if (nunits_out != nunits_in / 2) /* FORNOW */ if (nunits_out != nunits_in / 2) /* FORNOW */
return false; return false;
if (! INTEGRAL_TYPE_P (TREE_TYPE (scalar_dest))
|| !INTEGRAL_TYPE_P (TREE_TYPE (op0)))
return false;
/* Check the operands of the operation. */ /* Check the operands of the operation. */
if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt0)) if (!vect_is_simple_use (op0, loop_vinfo, &def_stmt, &def, &dt0))
{ {
@ -2772,7 +2780,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
S3: &base + 1 = x1 S3: &base + 1 = x1
S4: &base + 3 = x3 S4: &base + 3 = x3
We create vectorized storess starting from base address (the access of the We create vectorized stores starting from base address (the access of the
first stmt in the chain (S2 in the above example), when the last store stmt first stmt in the chain (S2 in the above example), when the last store stmt
of the chain (S4) is reached: of the chain (S4) is reached:
@ -2811,8 +2819,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
as an input to vect_permute_store_chain(), and OPRNDS as an input as an input to vect_permute_store_chain(), and OPRNDS as an input
to vect_get_vec_def_for_stmt_copy() for the next copy. to vect_get_vec_def_for_stmt_copy() for the next copy.
If the store is not strided, GROUP_SIZE is 1, and DR_CHAIN and If the store is not strided, GROUP_SIZE is 1, and DR_CHAIN and
OPRNDS are of size 1. OPRNDS are of size 1. */
*/
next_stmt = first_stmt; next_stmt = first_stmt;
for (i = 0; i < group_size; i++) for (i = 0; i < group_size; i++)
{ {
@ -2820,8 +2827,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
is the exact number of stmts in the chain. Therefore, NEXT_STMT is the exact number of stmts in the chain. Therefore, NEXT_STMT
can't be NULL_TREE. In case that there is no interleaving, can't be NULL_TREE. In case that there is no interleaving,
GROUP_SIZE is 1, and only one iteration of the loop will be GROUP_SIZE is 1, and only one iteration of the loop will be
executed. executed. */
*/
gcc_assert (next_stmt); gcc_assert (next_stmt);
op = GIMPLE_STMT_OPERAND (next_stmt, 1); op = GIMPLE_STMT_OPERAND (next_stmt, 1);
vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt, NULL); vec_oprnd = vect_get_vec_def_for_operand (op, next_stmt, NULL);
@ -2841,8 +2847,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
and OPRNDS as an input to vect_get_vec_def_for_stmt_copy() for the and OPRNDS as an input to vect_get_vec_def_for_stmt_copy() for the
next copy. next copy.
If the store is not strided, GROUP_SIZE is 1, and DR_CHAIN and If the store is not strided, GROUP_SIZE is 1, and DR_CHAIN and
OPRNDS are of size 1. OPRNDS are of size 1. */
*/
for (i = 0; i < group_size; i++) for (i = 0; i < group_size; i++)
{ {
vec_oprnd = vect_get_vec_def_for_stmt_copy (dt, vec_oprnd = vect_get_vec_def_for_stmt_copy (dt,
@ -2907,7 +2912,7 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
} }
prev_stmt_info = vinfo_for_stmt (new_stmt); prev_stmt_info = vinfo_for_stmt (new_stmt);
next_stmt = DR_GROUP_NEXT_DR (vinfo_for_stmt (next_stmt)); next_stmt = DR_GROUP_NEXT_DR (vinfo_for_stmt (next_stmt));
if (!next_stmt) if (!next_stmt)
break; break;
/* Bump the vector pointer. */ /* Bump the vector pointer. */

15
gcc/tree-vectorizer.h
View File

@ -300,6 +300,21 @@ vinfo_for_stmt (tree stmt)
return ann ? (stmt_vec_info) ann->common.aux : NULL; return ann ? (stmt_vec_info) ann->common.aux : NULL;
} }
static inline bool
is_pattern_stmt_p (stmt_vec_info stmt_info)
{
tree related_stmt;
stmt_vec_info related_stmt_info;
related_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
if (related_stmt
&& (related_stmt_info = vinfo_for_stmt (related_stmt))
&& STMT_VINFO_IN_PATTERN_P (related_stmt_info))
return true;
return false;
}
/*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/
/* Info on data references alignment. */ /* Info on data references alignment. */
/*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/