From: Richard Biener Date: Wed, 23 Feb 2022 10:15:38 +0000 (+0100) Subject: tree-optimization/101636 - CTOR vectorization ICE X-Git-Tag: upstream/12.2.0~1338 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=6e80c4f1ad9046b0a7c105660cc7b3dcae0fdb8f;p=platform%2Fupstream%2Fgcc.git tree-optimization/101636 - CTOR vectorization ICE The following fixes an ICE when vectorizing the defs of a CTOR results in a different vector type than expected. That can happen with AARCH64 SVE and a fixed vector length as noted in r10-5979 and on x86 with AVX512 mask CTORs and trying to re-vectorize using SSE as shown in this bug. The fix is simply to reject the vectorization when it didn't produce the desired type. 2022-02-23 Richard Biener PR tree-optimization/101636 * tree-vect-slp.cc (vect_print_slp_tree): Dump the vector type of the node. (vect_slp_analyze_operations): Make sure the CTOR is vectorized with an expected type. (vectorize_slp_instance_root_stmt): Revert r10-5979 fix. * gcc.target/i386/pr101636.c: New testcase. * c-c++-common/torture/pr101636.c: Likewise. --- diff --git a/gcc/testsuite/c-c++-common/torture/pr101636.c b/gcc/testsuite/c-c++-common/torture/pr101636.c new file mode 100644 index 0000000..aedaa1f --- /dev/null +++ b/gcc/testsuite/c-c++-common/torture/pr101636.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-ftree-vectorize -fno-vect-cost-model" } */ +/* { dg-additional-options "-mavx512f" { target x86_64-*-* i?86-*-* } } */ + +static inline int +foo (int y, int a) +{ + return (y && a) ? a : 0; +} + +void +bar (int *__restrict a, int *__restrict d, int *__restrict e, int i) +{ + while (i < 1) + { + e[8] = e[7] = e[6] = e[5] = e[4] = e[3] = e[2] = e[1] = e[0] + = foo (d[8], a[8]); + e[9] = foo (d[9], a[9]); + e[10] = foo (d[0], a[0]); + e[11] = foo (d[1], a[1]); + e[12] = foo (d[12], a[12]); + e[13] = foo (d[13], a[13]); + e[14] = foo (d[4], a[4]); + e[15] = foo (d[15], a[15]); + + a += 16; + e += 1; + i += 1; + } +} diff --git a/gcc/testsuite/gcc.target/i386/pr101636.c b/gcc/testsuite/gcc.target/i386/pr101636.c new file mode 100644 index 0000000..76399cc --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr101636.c @@ -0,0 +1,94 @@ +/* { dg-do compile } */ +/* { dg-options "-fgimple -O -mavx512f -ftree-vectorize -fno-vect-cost-model" } */ + +typedef _Bool sbool1 __attribute__((signed_bool_precision(1))); +typedef int v16si __attribute__((vector_size(64))); +typedef v16si v16sim __attribute__((vector_mask)); +typedef long v16di __attribute__((vector_size(128))); + +void __GIMPLE (ssa,guessed_local(118111600),startwith("slp")) +bar (int * restrict a, int * restrict d, int * restrict e) +{ + int * vectp_14; + v16si * vectp_e_13; + v16si vect_iftmp_12; + v16sim mask__75_11; + v16sim mask__74_10; + v16si vect__6_9; + v16si vect__1_8; + int * vectp_7; + v16si * vectp_a_6; + int _2; + int _5; + int _7; + int _9; + int _11; + int _13; + int _15; + int _17; + _Bool _41; + _Bool _49; + _Bool _53; + _Bool _57; + _Bool _61; + _Bool _65; + _Bool _69; + _Bool _73; + sbool1 _135; + sbool1 _136; + sbool1 _137; + sbool1 _138; + sbool1 _139; + sbool1 _140; + sbool1 _141; + sbool1 _142; + sbool1 _143; + sbool1 _144; + sbool1 _145; + sbool1 _146; + sbool1 _147; + sbool1 _148; + sbool1 _149; + sbool1 _150; + v16sim _151; + + __BB(2,guessed_local(105119324)): + _2 = __MEM (d_26(D) + _Literal (int * restrict) 32); + _73 = _2 != 0; + _5 = __MEM (d_26(D) + _Literal (int * restrict) 36); + _69 = _5 != 0; + _7 = __MEM (d_26(D)); + _65 = _7 != 0; + _9 = __MEM (d_26(D) + _Literal (int * restrict) 4); + _61 = _9 != 0; + _11 = __MEM (d_26(D) + _Literal (int * restrict) 48); + _57 = _11 != 0; + _13 = __MEM (d_26(D) + _Literal (int * restrict) 52); + _53 = _13 != 0; + _15 = __MEM (d_26(D) + _Literal (int * restrict) 16); + _41 = _15 != 0; + _17 = __MEM (d_26(D) + _Literal (int * restrict) 60); + _49 = _17 != 0; + _135 = _49 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _136 = _41 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _137 = _53 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _138 = _57 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _139 = _61 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _140 = _65 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _141 = _69 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _142 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _143 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _144 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _145 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _146 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _147 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _148 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _149 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _150 = _73 ? _Literal (sbool1) -1 : _Literal (sbool1) 0; + _151 = _Literal (v16sim) {_150, _149, _148, _147, _146, _145, _144, _143, _142, _141, _140, _139, _138, _137, _136, _135}; + vect__1_8_154 = __MEM ((int * restrict)a_22(D)); + vect_iftmp_12_158 = _151 ? vect__6_9_154 : _Literal (v16si) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + __MEM ((int * restrict)e_23(D)) = vect_iftmp_12_158; + return; +} + diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 341bd52..f9bbc87 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -2468,7 +2468,7 @@ vect_print_slp_tree (dump_flags_t dump_kind, dump_location_t loc, dump_metadata_t metadata (dump_kind, loc.get_impl_location ()); dump_user_location_t user_loc = loc.get_user_location (); - dump_printf_loc (metadata, user_loc, "node%s %p (max_nunits=%u, refcnt=%u)\n", + dump_printf_loc (metadata, user_loc, "node%s %p (max_nunits=%u, refcnt=%u)", SLP_TREE_DEF_TYPE (node) == vect_external_def ? " (external)" : (SLP_TREE_DEF_TYPE (node) == vect_constant_def @@ -2476,6 +2476,9 @@ vect_print_slp_tree (dump_flags_t dump_kind, dump_location_t loc, : ""), node, estimated_poly_value (node->max_nunits), SLP_TREE_REF_COUNT (node)); + if (SLP_TREE_VECTYPE (node)) + dump_printf (metadata, " %T", SLP_TREE_VECTYPE (node)); + dump_printf (metadata, "\n"); if (SLP_TREE_DEF_TYPE (node) == vect_internal_def) { if (SLP_TREE_CODE (node) == VEC_PERM_EXPR) @@ -4925,7 +4928,13 @@ vect_slp_analyze_operations (vec_info *vinfo) /* CTOR instances require vectorized defs for the SLP tree root. */ || (SLP_INSTANCE_KIND (instance) == slp_inst_kind_ctor && (SLP_TREE_DEF_TYPE (SLP_INSTANCE_TREE (instance)) - != vect_internal_def)) + != vect_internal_def + /* Make sure we vectorized with the expected type. */ + || !useless_type_conversion_p + (TREE_TYPE (TREE_TYPE (gimple_assign_rhs1 + (instance->root_stmts[0]->stmt))), + TREE_TYPE (SLP_TREE_VECTYPE + (SLP_INSTANCE_TREE (instance)))))) /* Check we can vectorize the reduction. */ || (SLP_INSTANCE_KIND (instance) == slp_inst_kind_bb_reduc && !vectorizable_bb_reduc_epilogue (instance, &cost_vec))) @@ -7373,10 +7382,6 @@ vectorize_slp_instance_root_stmt (slp_tree node, slp_instance instance) gimple *child_stmt = SLP_TREE_VEC_STMTS (node)[0]; tree vect_lhs = gimple_get_lhs (child_stmt); tree root_lhs = gimple_get_lhs (instance->root_stmts[0]->stmt); - if (!useless_type_conversion_p (TREE_TYPE (root_lhs), - TREE_TYPE (vect_lhs))) - vect_lhs = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (root_lhs), - vect_lhs); rstmt = gimple_build_assign (root_lhs, vect_lhs); } else if (SLP_TREE_NUMBER_OF_VEC_STMTS (node) > 1)