From 91d80cf4bd2827dd9c40fe6a7c719c909d79083d Mon Sep 17 00:00:00 2001 From: Duan bo Date: Mon, 12 Oct 2020 12:32:57 +0100 Subject: [PATCH] vect: Fix an ICE in vect_recog_mask_conversion_pattern When processing the cond expression, vect_recog_mask_conversion_pattern doesn't consider the situation that two operands of rhs1 are different vectypes, leading to a vect ICE. This patch adds the identification and handling of the situation to fix the problem. gcc/ChangeLog: PR target/96757 * tree-vect-patterns.c (vect_recog_mask_conversion_pattern): Add the identification and handling of the dropped situation in the cond expression processing phase. gcc/testsuite/ChangeLog: PR target/96757 * gcc.target/aarch64/pr96757.c: New test. --- gcc/testsuite/gcc.target/aarch64/pr96757.c | 23 ++++++++++ gcc/tree-vect-patterns.c | 51 +++++++++++++++++++--- 2 files changed, 68 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/pr96757.c diff --git a/gcc/testsuite/gcc.target/aarch64/pr96757.c b/gcc/testsuite/gcc.target/aarch64/pr96757.c new file mode 100644 index 00000000000..122e39dca0e --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/pr96757.c @@ -0,0 +1,23 @@ +/* PR target/96757 */ +/* { dg-do compile } */ +/* { dg-options "-O3" } */ + +short +fun1(short i, short j) +{ + return i * j; +} + +int +fun(int a, int b, int c) +{ + int *v, z, k, m; + short f, d; + for (int i=0; i m; + z = f > k; + *v += fun1(z,b); + } +} diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c index 71e4e106202..bc5f2e65001 100644 --- a/gcc/tree-vect-patterns.c +++ b/gcc/tree-vect-patterns.c @@ -4245,6 +4245,8 @@ vect_recog_mask_conversion_pattern (vec_info *vinfo, tree lhs = NULL_TREE, rhs1, rhs2, tmp, rhs1_type, rhs2_type; tree vectype1, vectype2; stmt_vec_info pattern_stmt_info; + tree rhs1_op0 = NULL_TREE, rhs1_op1 = NULL_TREE; + tree rhs1_op0_type = NULL_TREE, rhs1_op1_type = NULL_TREE; /* Check for MASK_LOAD ans MASK_STORE calls requiring mask conversion. */ if (is_gimple_call (last_stmt) @@ -4344,9 +4346,37 @@ vect_recog_mask_conversion_pattern (vec_info *vinfo, it is better for b1 and b2 to use the mask type associated with int elements rather bool (byte) elements. */ - rhs1_type = integer_type_for_mask (TREE_OPERAND (rhs1, 0), vinfo); - if (!rhs1_type) - rhs1_type = TREE_TYPE (TREE_OPERAND (rhs1, 0)); + rhs1_op0 = TREE_OPERAND (rhs1, 0); + rhs1_op1 = TREE_OPERAND (rhs1, 1); + if (!rhs1_op0 || !rhs1_op1) + return NULL; + rhs1_op0_type = integer_type_for_mask (rhs1_op0, vinfo); + rhs1_op1_type = integer_type_for_mask (rhs1_op1, vinfo); + + if (!rhs1_op0_type) + rhs1_type = TREE_TYPE (rhs1_op0); + else if (!rhs1_op1_type) + rhs1_type = TREE_TYPE (rhs1_op1); + else if (TYPE_PRECISION (rhs1_op0_type) + != TYPE_PRECISION (rhs1_op1_type)) + { + int tmp0 = (int) TYPE_PRECISION (rhs1_op0_type) + - (int) TYPE_PRECISION (TREE_TYPE (lhs)); + int tmp1 = (int) TYPE_PRECISION (rhs1_op1_type) + - (int) TYPE_PRECISION (TREE_TYPE (lhs)); + if ((tmp0 > 0 && tmp1 > 0) || (tmp0 < 0 && tmp1 < 0)) + { + if (abs (tmp0) > abs (tmp1)) + rhs1_type = rhs1_op1_type; + else + rhs1_type = rhs1_op0_type; + } + else + rhs1_type = build_nonstandard_integer_type + (TYPE_PRECISION (TREE_TYPE (lhs)), 1); + } + else + rhs1_type = rhs1_op0_type; } else return NULL; @@ -4364,8 +4394,8 @@ vect_recog_mask_conversion_pattern (vec_info *vinfo, name from the outset. */ if (known_eq (TYPE_VECTOR_SUBPARTS (vectype1), TYPE_VECTOR_SUBPARTS (vectype2)) - && (TREE_CODE (rhs1) == SSA_NAME - || rhs1_type == TREE_TYPE (TREE_OPERAND (rhs1, 0)))) + && !rhs1_op0_type + && !rhs1_op1_type) return NULL; /* If rhs1 is invariant and we can promote it leave the COND_EXPR @@ -4397,7 +4427,16 @@ vect_recog_mask_conversion_pattern (vec_info *vinfo, if (TREE_CODE (rhs1) != SSA_NAME) { tmp = vect_recog_temp_ssa_var (TREE_TYPE (rhs1), NULL); - pattern_stmt = gimple_build_assign (tmp, rhs1); + if (rhs1_op0_type + && TYPE_PRECISION (rhs1_op0_type) != TYPE_PRECISION (rhs1_type)) + rhs1_op0 = build_mask_conversion (vinfo, rhs1_op0, + vectype2, stmt_vinfo); + if (rhs1_op1_type + && TYPE_PRECISION (rhs1_op1_type) != TYPE_PRECISION (rhs1_type)) + rhs1_op1 = build_mask_conversion (vinfo, rhs1_op1, + vectype2, stmt_vinfo); + pattern_stmt = gimple_build_assign (tmp, TREE_CODE (rhs1), + rhs1_op0, rhs1_op1); rhs1 = tmp; append_pattern_def_seq (vinfo, stmt_vinfo, pattern_stmt, vectype2, rhs1_type); -- 2.30.2