[gcc(refs/vendors/redhat/heads/gcc-8-branch)] vect: Fix up lowering of TRUNC_MOD_EXPR by negative constant [PR94524]

[gcc(refs/vendors/redhat/heads/gcc-8-branch)] vect: Fix up lowering of TRUNC_MOD_EXPR by negative constant [PR94524]

[Jakub Jelinek]

https://gcc.gnu.org/g:8c18343db65830de3b1ead80698ae9d06b63a3d8

commit 8c18343db65830de3b1ead80698ae9d06b63a3d8
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Wed Apr 8 21:22:05 2020 +0200

    vect: Fix up lowering of TRUNC_MOD_EXPR by negative constant [PR94524]
    
    The first testcase below is miscompiled, because for the division part
    of the lowering we canonicalize negative divisors to their absolute value
    (similarly how expmed.c canonicalizes it), but when multiplying the division
    result back by the VECTOR_CST, we use the original constant, which can
    contain negative divisors.
    
    Fixed by computing ABS_EXPR of the VECTOR_CST.  Unfortunately, fold-const.c
    doesn't support const_unop (ABS_EXPR, VECTOR_CST) and I think it is too late
    in GCC 10 cycle to add it now.
    
    Furthermore, while modulo by most negative constant happens to return the
    right value, it does that only by invoking UB in the IL, because
    we then expand division by that 1U+INT_MAX and say for INT_MIN % INT_MIN
    compute the division as -1, and then multiply by INT_MIN, which is signed
    integer overflow.  We in theory could do the computation in unsigned vector
    types instead, but is it worth bothering.  People that are doing % INT_MIN
    are either testing for standard conformance, or doing something wrong.
    So, I've also added punting on % INT_MIN, both in vect lowering and vect
    pattern recognition (we punt already for / INT_MIN).
    
    2020-04-08  Jakub Jelinek  <jakub@redhat.com>
    
            PR tree-optimization/94524
            * tree-vect-generic.c (expand_vector_divmod): If any elt of op1 is
            negative for signed TRUNC_MOD_EXPR, multiply with absolute value of
            op1 rather than op1 itself at the end.  Punt for signed modulo by
            most negative constant.
            * tree-vect-patterns.c (vect_recog_divmod_pattern): Punt for signed
            modulo by most negative constant.
    
            * gcc.c-torture/execute/pr94524-1.c: New test.
            * gcc.c-torture/execute/pr94524-2.c: New test.
    
    (cherry picked from commit f52eb4f988992d393c69ee4ab76f236dced80e36)

Diff:
---
 gcc/testsuite/gcc.c-torture/execute/pr94524-1.c | 19 +++++++++++++++++++
 gcc/testsuite/gcc.c-torture/execute/pr94524-2.c | 25 +++++++++++++++++++++++++
 gcc/tree-vect-generic.c                         | 25 +++++++++++++++++++++++--
 gcc/tree-vect-patterns.c                        |  4 ++--
 4 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/gcc/testsuite/gcc.c-torture/execute/pr94524-1.c b/gcc/testsuite/gcc.c-torture/execute/pr94524-1.c
new file mode 100644
index 00000000000..e7365ad97fd
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr94524-1.c
@@ -0,0 +1,19 @@
+/* PR tree-optimization/94524 */
+
+typedef signed char __attribute__ ((__vector_size__ (16))) V;
+
+static __attribute__ ((__noinline__, __noclone__)) V
+foo (V c)
+{
+  c %= (signed char) -19;
+  return (V) c;
+}
+
+int
+main ()
+{
+  V x = foo ((V) { 31 });
+  if (x[0] != 12)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr94524-2.c b/gcc/testsuite/gcc.c-torture/execute/pr94524-2.c
new file mode 100644
index 00000000000..9c74b7be403
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr94524-2.c
@@ -0,0 +1,25 @@
+/* PR tree-optimization/94524 */
+
+typedef signed char __attribute__ ((__vector_size__ (16))) V;
+
+static __attribute__ ((__noinline__, __noclone__)) V
+foo (V c)
+{
+  c %= (signed char) -128;
+  return (V) c;
+}
+
+int
+main ()
+{
+  V x = foo ((V) { -128 });
+  if (x[0] != 0)
+    __builtin_abort ();
+  x = foo ((V) { -127 });
+  if (x[0] != -127)
+    __builtin_abort ();
+  x = foo ((V) { 127 });
+  if (x[0] != 127)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c
index 9d6338371e9..1070403c192 100644
--- a/gcc/tree-vect-generic.c
+++ b/gcc/tree-vect-generic.c
@@ -433,6 +433,7 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
 {
   bool use_pow2 = true;
   bool has_vector_shift = true;
+  bool use_abs_op1 = false;
   int mode = -1, this_mode;
   int pre_shift = -1, post_shift;
   unsigned int nunits = nunits_for_known_piecewise_op (type);
@@ -573,8 +574,11 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
 
 	  /* n rem d = n rem -d */
 	  if (code == TRUNC_MOD_EXPR && d < 0)
-	    d = abs_d;
-	  else if (abs_d == HOST_WIDE_INT_1U << (prec - 1))
+	    {
+	      d = abs_d;
+	      use_abs_op1 = true;
+	    }
+	  if (abs_d == HOST_WIDE_INT_1U << (prec - 1))
 	    {
 	      /* This case is not handled correctly below.  */
 	      mode = -2;
@@ -854,6 +858,23 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
   if (op == unknown_optab
       || optab_handler (op, TYPE_MODE (type)) == CODE_FOR_nothing)
     return NULL_TREE;
+  if (use_abs_op1)
+    {
+      tree_vector_builder elts;
+      if (!elts.new_unary_operation (type, op1, false))
+	return NULL_TREE;
+      unsigned int count = elts.encoded_nelts ();
+      for (unsigned int i = 0; i < count; ++i)
+	{
+	  tree elem1 = VECTOR_CST_ELT (op1, i);
+
+	  tree elt = const_unop (ABS_EXPR, TREE_TYPE (elem1), elem1);
+	  if (elt == NULL_TREE)
+	    return NULL_TREE;
+	  elts.quick_push (elt);
+	}
+      op1 = elts.build ();
+    }
   tem = gimplify_build2 (gsi, MULT_EXPR, type, cur_op, op1);
   op = optab_for_tree_code (MINUS_EXPR, type, optab_default);
   if (op == unknown_optab
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c
index 30c3daaa32f..de21c4bbd3f 100644
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -2926,8 +2926,8 @@ vect_recog_divmod_pattern (vec<gimple *> *stmts,
 	  d = abs_d;
 	  oprnd1 = build_int_cst (itype, abs_d);
 	}
-      else if (HOST_BITS_PER_WIDE_INT >= prec
-	       && abs_d == HOST_WIDE_INT_1U << (prec - 1))
+      if (HOST_BITS_PER_WIDE_INT >= prec
+	  && abs_d == HOST_WIDE_INT_1U << (prec - 1))
 	/* This case is not handled correctly below.  */
 	return NULL;