From 99f81ffb527eb0736e864574b58a341f62f8d9b8 Mon Sep 17 00:00:00 2001 From: rguenth Date: Thu, 5 Sep 2013 12:45:20 +0000 Subject: [PATCH] 2013-09-05 Richard Biener PR tree-optimization/58137 * tree-vect-stmts.c (get_vectype_for_scalar_type_and_size): Do not create vectors of pointers. * tree-vect-loop.c (get_initial_def_for_induction): Use proper types for the components of the vector initializer. * tree-cfg.c (verify_gimple_assign_binary): Remove special-casing allowing pointer vectors with PLUS_EXPR/MINUS_EXPR. * gcc.target/i386/pr58137.c: New testcase. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@202282 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 10 ++++++++++ gcc/testsuite/ChangeLog | 5 +++++ gcc/testsuite/gcc.target/i386/pr58137.c | 33 +++++++++++++++++++++++++++++++++ gcc/tree-cfg.c | 31 ++++++++++--------------------- gcc/tree-vect-loop.c | 16 ++++++++-------- gcc/tree-vect-stmts.c | 3 +-- 6 files changed, 67 insertions(+), 31 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr58137.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d7b6bfa6728..7374a857309 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,13 @@ +2013-09-05 Richard Biener + + PR tree-optimization/58137 + * tree-vect-stmts.c (get_vectype_for_scalar_type_and_size): + Do not create vectors of pointers. + * tree-vect-loop.c (get_initial_def_for_induction): Use proper + types for the components of the vector initializer. + * tree-cfg.c (verify_gimple_assign_binary): Remove special-casing + allowing pointer vectors with PLUS_EXPR/MINUS_EXPR. + 2013-09-05 Martin Jambor * ipa-prop.c (remove_described_reference): Accept missing references, diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 5431d212acc..d34ee5e7571 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2013-09-05 Richard Biener + + PR tree-optimization/58137 + * gcc.target/i386/pr58137.c: New testcase. + 2013-09-05 Martin Jambor * g++.dg/ipa/remref-1.C: New test. diff --git a/gcc/testsuite/gcc.target/i386/pr58137.c b/gcc/testsuite/gcc.target/i386/pr58137.c new file mode 100644 index 00000000000..0a7daf83cd5 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr58137.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -mavx2" } */ + +typedef unsigned int U32; + +struct sv { + void* sv_any; + U32 sv_refcnt; + U32 sv_flags; +}; +typedef struct sv SV; + +struct xrv { + SV * xrv_rv; +}; +typedef struct xrv XRV; + +extern XRV * PL_xrv_root; + +void +more_xrv (void) +{ + register XRV* xrv; + register XRV* xrvend; + xrv = PL_xrv_root; + xrvend = &xrv[200 / sizeof (XRV) - 1]; + while (xrv < xrvend) + { + xrv->xrv_rv = (SV*)(xrv + 1); + xrv++; + } + xrv->xrv_rv = 0; +} diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index bc1e1ba90fc..c74b9885933 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -3571,11 +3571,10 @@ verify_gimple_assign_binary (gimple stmt) case PLUS_EXPR: case MINUS_EXPR: { - /* We use regular PLUS_EXPR and MINUS_EXPR for vectors. - ??? This just makes the checker happy and may not be what is - intended. */ - if (TREE_CODE (lhs_type) == VECTOR_TYPE - && POINTER_TYPE_P (TREE_TYPE (lhs_type))) + tree lhs_etype = lhs_type; + tree rhs1_etype = rhs1_type; + tree rhs2_etype = rhs2_type; + if (TREE_CODE (lhs_type) == VECTOR_TYPE) { if (TREE_CODE (rhs1_type) != VECTOR_TYPE || TREE_CODE (rhs2_type) != VECTOR_TYPE) @@ -3583,22 +3582,13 @@ verify_gimple_assign_binary (gimple stmt) error ("invalid non-vector operands to vector valued plus"); return true; } - lhs_type = TREE_TYPE (lhs_type); - rhs1_type = TREE_TYPE (rhs1_type); - rhs2_type = TREE_TYPE (rhs2_type); - /* PLUS_EXPR is commutative, so we might end up canonicalizing - the pointer to 2nd place. */ - if (POINTER_TYPE_P (rhs2_type)) - { - tree tem = rhs1_type; - rhs1_type = rhs2_type; - rhs2_type = tem; - } - goto do_pointer_plus_expr_check; + lhs_etype = TREE_TYPE (lhs_type); + rhs1_etype = TREE_TYPE (rhs1_type); + rhs2_etype = TREE_TYPE (rhs2_type); } - if (POINTER_TYPE_P (lhs_type) - || POINTER_TYPE_P (rhs1_type) - || POINTER_TYPE_P (rhs2_type)) + if (POINTER_TYPE_P (lhs_etype) + || POINTER_TYPE_P (rhs1_etype) + || POINTER_TYPE_P (rhs2_etype)) { error ("invalid (pointer) operands to plus/minus"); return true; @@ -3610,7 +3600,6 @@ verify_gimple_assign_binary (gimple stmt) case POINTER_PLUS_EXPR: { -do_pointer_plus_expr_check: if (!POINTER_TYPE_P (rhs1_type) || !useless_type_conversion_p (lhs_type, rhs1_type) || !ptrofftype_p (rhs2_type)) diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c index 762a894a500..9b4b1892984 100644 --- a/gcc/tree-vect-loop.c +++ b/gcc/tree-vect-loop.c @@ -3133,7 +3133,6 @@ get_initial_def_for_induction (gimple iv_phi) stmt_vec_info stmt_vinfo = vinfo_for_stmt (iv_phi); loop_vec_info loop_vinfo = STMT_VINFO_LOOP_VINFO (stmt_vinfo); struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo); - tree scalar_type; tree vectype; int nunits; edge pe = loop_preheader_edge (loop); @@ -3185,8 +3184,7 @@ get_initial_def_for_induction (gimple iv_phi) gcc_assert (ok); pe = loop_preheader_edge (iv_loop); - scalar_type = TREE_TYPE (init_expr); - vectype = get_vectype_for_scalar_type (scalar_type); + vectype = get_vectype_for_scalar_type (TREE_TYPE (init_expr)); resvectype = get_vectype_for_scalar_type (TREE_TYPE (PHI_RESULT (iv_phi))); gcc_assert (vectype); nunits = TYPE_VECTOR_SUBPARTS (vectype); @@ -3229,8 +3227,11 @@ get_initial_def_for_induction (gimple iv_phi) /* iv_loop is the loop to be vectorized. Create: vec_init = [X, X+S, X+2*S, X+3*S] (S = step_expr, X = init_expr) */ - new_var = vect_get_new_vect_var (scalar_type, vect_scalar_var, "var_"); - new_name = force_gimple_operand (init_expr, &stmts, false, new_var); + new_var = vect_get_new_vect_var (TREE_TYPE (vectype), + vect_scalar_var, "var_"); + new_name = force_gimple_operand (fold_convert (TREE_TYPE (vectype), + init_expr), + &stmts, false, new_var); if (stmts) { new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts); @@ -3243,9 +3244,8 @@ get_initial_def_for_induction (gimple iv_phi) for (i = 1; i < nunits; i++) { /* Create: new_name_i = new_name + step_expr */ - enum tree_code code = POINTER_TYPE_P (scalar_type) - ? POINTER_PLUS_EXPR : PLUS_EXPR; - new_name = fold_build2 (code, scalar_type, new_name, step_expr); + new_name = fold_build2 (PLUS_EXPR, TREE_TYPE (new_name), + new_name, step_expr); if (!is_gimple_min_invariant (new_name)) { init_stmt = gimple_build_assign (new_var, new_name); diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index 7b8e7087b68..bc4ea1e3097 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -6203,8 +6203,7 @@ get_vectype_for_scalar_type_and_size (tree scalar_type, unsigned size) corresponding to that mode. The theory is that any use that would cause problems with this will disable vectorization anyway. */ else if (!SCALAR_FLOAT_TYPE_P (scalar_type) - && !INTEGRAL_TYPE_P (scalar_type) - && !POINTER_TYPE_P (scalar_type)) + && !INTEGRAL_TYPE_P (scalar_type)) scalar_type = lang_hooks.types.type_for_mode (inner_mode, 1); /* We can't build a vector type of elements with alignment bigger than -- 2.11.4.GIT