From 1aa22f279c41372c709e65bebbb945ffd804aeb0 Mon Sep 17 00:00:00 2001 From: hjl Date: Sun, 3 Oct 2010 23:57:01 +0000 Subject: [PATCH] Revert revision 164914. gcc/ 2010-10-03 H.J. Lu * tree-vect-data-refs.c (vect_analyze_data_ref_access): Revert revision 164914. (vect_create_data_ref_ptr): Likewise. * tree-vect-stmts.c (vectorizable_store): Likewise. (perm_mask_for_reverse): Likewise. (reverse_vec_elements): Likewise. (vectorizable_load): Likewise. gcc/testsuite/ 2010-10-03 H.J. Lu * g++.dg/torture/pr45764.C: Revert revision 164914. * gcc.dg/vect/pr43432.c: Likewise. * gcc.dg/vect/vect-114.c: Likewise. * gcc.dg/vect/vect-15.c: Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@164919 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 10 ++++ gcc/testsuite/ChangeLog | 7 +++ gcc/testsuite/g++.dg/torture/pr45764.C | 25 -------- gcc/testsuite/gcc.dg/vect/pr43432.c | 2 +- gcc/testsuite/gcc.dg/vect/vect-114.c | 2 +- gcc/testsuite/gcc.dg/vect/vect-15.c | 2 +- gcc/tree-vect-data-refs.c | 8 ++- gcc/tree-vect-stmts.c | 106 +++++++++++++++++++++++++++++++++ 8 files changed, 133 insertions(+), 29 deletions(-) delete mode 100644 gcc/testsuite/g++.dg/torture/pr45764.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 049a1db..b2cfc87 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2010-10-03 H.J. Lu + + * tree-vect-data-refs.c (vect_analyze_data_ref_access): Revert + revision 164914. + (vect_create_data_ref_ptr): Likewise. + * tree-vect-stmts.c (vectorizable_store): Likewise. + (perm_mask_for_reverse): Likewise. + (reverse_vec_elements): Likewise. + (vectorizable_load): Likewise. + 2010-10-03 Francois-Xavier Coudert * cppbuiltin.c: New file. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 269e4e0..2ffaa9d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,10 @@ +2010-10-03 H.J. Lu + + * g++.dg/torture/pr45764.C: Revert revision 164914. + * gcc.dg/vect/pr43432.c: Likewise. + * gcc.dg/vect/vect-114.c: Likewise. + * gcc.dg/vect/vect-15.c: Likewise. + 2010-10-03 Jason Merrill * g++.dg/cpp0x/sfinae5.C: New. diff --git a/gcc/testsuite/g++.dg/torture/pr45764.C b/gcc/testsuite/g++.dg/torture/pr45764.C deleted file mode 100644 index 56f32be..0000000 --- a/gcc/testsuite/g++.dg/torture/pr45764.C +++ /dev/null @@ -1,25 +0,0 @@ -// { dg-do run } - -int result[64][16]; - -int main() -{ - double dbuf[1000] = {0.0}; - int ibuf[900]; - - double d1 = 0.0; - double d2 = 0.0; - for (int i = 0; i < 900; ++i) { - ibuf[i] = int(d2 - d1); - d1 += dbuf[i]; - d2 += dbuf[i + 64]; - } - - for (int i = 0; i < 64; ++i) { - for (int j = 0; j < 8; ++j) { - result[i][ j] = ibuf[64 - i + 64 * j]; - result[i][15 - j] = ibuf[ i + 64 * j]; - } - } - return 0; -} diff --git a/gcc/testsuite/gcc.dg/vect/pr43432.c b/gcc/testsuite/gcc.dg/vect/pr43432.c index a979a5c..18c0dba 100644 --- a/gcc/testsuite/gcc.dg/vect/pr43432.c +++ b/gcc/testsuite/gcc.dg/vect/pr43432.c @@ -10,5 +10,5 @@ int len){ dst[i] = src0[i] * src1[-i]; } -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail { vect_perm } } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target { vect_perm } } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-114.c b/gcc/testsuite/gcc.dg/vect/vect-114.c index 4964a83..f9132ac 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-114.c +++ b/gcc/testsuite/gcc.dg/vect/vect-114.c @@ -35,6 +35,6 @@ int main (void) } /* { dg-final { scan-tree-dump-times "vectorized 0 loops" 1 "vect" { target { ! vect_perm } } } } */ -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_perm } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_perm } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-15.c b/gcc/testsuite/gcc.dg/vect/vect-15.c index d4621d3..87853c1 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-15.c +++ b/gcc/testsuite/gcc.dg/vect/vect-15.c @@ -35,5 +35,5 @@ int main (void) return main1 (); } -/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail vect_perm } } } */ +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { target vect_perm } } } */ /* { dg-final { cleanup-tree-dump "vect" } } */ diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index 0d1e338..7182513 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -2287,7 +2287,9 @@ vect_analyze_data_ref_access (struct data_reference *dr) } /* Consecutive? */ - if (!tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type))) + if (!tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type)) + || (dr_step < 0 + && !compare_tree_int (TYPE_SIZE_UNIT (scalar_type), -dr_step))) { /* Mark that it is not interleaving. */ DR_GROUP_FIRST_DR (vinfo_for_stmt (stmt)) = NULL; @@ -2970,6 +2972,7 @@ vect_create_data_ref_ptr (gimple stmt, struct loop *at_loop, tree vptr; gimple_stmt_iterator incr_gsi; bool insert_after; + bool negative; tree indx_before_incr, indx_after_incr; gimple incr; tree step; @@ -3002,6 +3005,7 @@ vect_create_data_ref_ptr (gimple stmt, struct loop *at_loop, *inv_p = true; else *inv_p = false; + negative = tree_int_cst_compare (step, size_zero_node) < 0; /* Create an expression for the first address accessed by this load in LOOP. */ @@ -3160,6 +3164,8 @@ vect_create_data_ref_ptr (gimple stmt, struct loop *at_loop, LOOP is zero. In this case the step here is also zero. */ if (*inv_p) step = size_zero_node; + else if (negative) + step = fold_build1 (NEGATE_EXPR, TREE_TYPE (step), step); standard_iv_increment_position (loop, &incr_gsi, &insert_after); diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index a758410..b120dc6 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -3145,6 +3145,13 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (!STMT_VINFO_DATA_REF (stmt_info)) return false; + if (tree_int_cst_compare (DR_STEP (dr), size_zero_node) < 0) + { + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "negative step for store."); + return false; + } + if (STMT_VINFO_STRIDED_ACCESS (stmt_info)) { strided_store = true; @@ -3425,6 +3432,68 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, return true; } +/* Given a vector type VECTYPE returns a builtin DECL to be used + for vector permutation and stores a mask into *MASK that implements + reversal of the vector elements. If that is impossible to do + returns NULL (and *MASK is unchanged). */ + +static tree +perm_mask_for_reverse (tree vectype, tree *mask) +{ + tree builtin_decl; + tree mask_element_type, mask_type; + tree mask_vec = NULL; + int i; + int nunits; + if (!targetm.vectorize.builtin_vec_perm) + return NULL; + + builtin_decl = targetm.vectorize.builtin_vec_perm (vectype, + &mask_element_type); + if (!builtin_decl || !mask_element_type) + return NULL; + + mask_type = get_vectype_for_scalar_type (mask_element_type); + nunits = TYPE_VECTOR_SUBPARTS (vectype); + if (TYPE_VECTOR_SUBPARTS (vectype) != TYPE_VECTOR_SUBPARTS (mask_type)) + return NULL; + + for (i = 0; i < nunits; i++) + mask_vec = tree_cons (NULL, build_int_cst (mask_element_type, i), mask_vec); + mask_vec = build_vector (mask_type, mask_vec); + + if (!targetm.vectorize.builtin_vec_perm_ok (vectype, mask_vec)) + return NULL; + if (mask) + *mask = mask_vec; + return builtin_decl; +} + +/* Given a vector variable X, that was generated for the scalar LHS of + STMT, generate instructions to reverse the vector elements of X, + insert them a *GSI and return the permuted vector variable. */ + +static tree +reverse_vec_elements (tree x, gimple stmt, gimple_stmt_iterator *gsi) +{ + tree vectype = TREE_TYPE (x); + tree mask_vec, builtin_decl; + tree perm_dest, data_ref; + gimple perm_stmt; + + builtin_decl = perm_mask_for_reverse (vectype, &mask_vec); + + perm_dest = vect_create_destination_var (gimple_assign_lhs (stmt), vectype); + + /* Generate the permute statement. */ + perm_stmt = gimple_build_call (builtin_decl, 3, x, x, mask_vec); + data_ref = make_ssa_name (perm_dest, perm_stmt); + gimple_call_set_lhs (perm_stmt, data_ref); + vect_finish_stmt_generation (stmt, perm_stmt, gsi); + + return data_ref; +} + /* vectorizable_load. Check if STMT reads a non scalar data-ref (array/pointer/structure) that @@ -3467,6 +3536,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, gimple first_stmt; tree scalar_type; bool inv_p; + bool negative; bool compute_in_loop = false; struct loop *at_loop; int vec_num; @@ -3529,6 +3599,14 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, if (!STMT_VINFO_DATA_REF (stmt_info)) return false; + negative = tree_int_cst_compare (DR_STEP (dr), size_zero_node) < 0; + if (negative && ncopies > 1) + { + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "multiple types with negative step."); + return false; + } + scalar_type = TREE_TYPE (DR_REF (dr)); mode = TYPE_MODE (vectype); @@ -3563,6 +3641,25 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, return false; } + if (negative) + { + gcc_assert (!strided_load); + alignment_support_scheme = vect_supportable_dr_alignment (dr, false); + if (alignment_support_scheme != dr_aligned + && alignment_support_scheme != dr_unaligned_supported) + { + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "negative step but alignment required."); + return false; + } + if (!perm_mask_for_reverse (vectype, NULL)) + { + if (vect_print_dump_info (REPORT_DETAILS)) + fprintf (vect_dump, "negative step and reversing not supported."); + return false; + } + } + if (!vec_stmt) /* transformation not required. */ { STMT_VINFO_TYPE (stmt_info) = load_vec_info_type; @@ -3737,6 +3834,9 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, else at_loop = loop; + if (negative) + offset = size_int (-TYPE_VECTOR_SUBPARTS (vectype) + 1); + prev_stmt_info = NULL; for (j = 0; j < ncopies; j++) { @@ -3925,6 +4025,12 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, gcc_unreachable (); /* FORNOW. */ } + if (negative) + { + new_temp = reverse_vec_elements (new_temp, stmt, gsi); + new_stmt = SSA_NAME_DEF_STMT (new_temp); + } + /* Collect vector loads and later create their permutation in vect_transform_strided_load (). */ if (strided_load || slp_perm) -- 2.7.4