2018-11-29 Jakub Jelinek <jakub@redhat.com>
+ PR target/88152
+ * tree.h (build_uniform_cst, uniform_integer_cst_p): Declare.
+ * tree.c (build_uniform_cst, uniform_integer_cst_p): New functions.
+ * match.pd (define_predicates): Add uniform_integer_cst_p.
+ (cmp @0 INTEGER_CST@1, cmp (convert?@2 @0) INTEGER_CST@1): Adjust
+ so that it works also for vector comparisons with uniform constants
+ with INTEGER_CST element.
+
PR target/88234
* config/rs6000/rs6000.c (rs6000_gimple_fold_builtin): For
vec_add and vec_sub builtins, perform PLUS_EXPR or MINUS_EXPR
tree_expr_nonzero_p
integer_valued_real_p
integer_pow2p
+ uniform_integer_cst_p
HONOR_NANS)
/* Operator lists. */
(for cmp (le gt)
acmp (lt ge)
(simplify
- (cmp @0 INTEGER_CST@1)
- (if (tree_int_cst_sgn (@1) == -1)
- (acmp @0 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) + 1); }))))
+ (cmp @0 uniform_integer_cst_p@1)
+ (with { tree cst = uniform_integer_cst_p (@1); }
+ (if (tree_int_cst_sgn (cst) == -1)
+ (acmp @0 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst)
+ + 1)); })))))
(for cmp (ge lt)
acmp (gt le)
(simplify
- (cmp @0 INTEGER_CST@1)
- (if (tree_int_cst_sgn (@1) == 1)
- (acmp @0 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) - 1); }))))
-
+ (cmp @0 uniform_integer_cst_p@1)
+ (with { tree cst = uniform_integer_cst_p (@1); }
+ (if (tree_int_cst_sgn (cst) == 1)
+ (acmp @0 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst) - 1)); })))))
/* We can simplify a logical negation of a comparison to the
inverted comparison. As we cannot compute an expression
/* Comparisons with the highest or lowest possible integer of
the specified precision will have known values. */
(simplify
- (cmp (convert?@2 @0) INTEGER_CST@1)
- (if ((INTEGRAL_TYPE_P (TREE_TYPE (@1)) || POINTER_TYPE_P (TREE_TYPE (@1)))
+ (cmp (convert?@2 @0) uniform_integer_cst_p@1)
+ (if ((INTEGRAL_TYPE_P (TREE_TYPE (@1))
+ || POINTER_TYPE_P (TREE_TYPE (@1))
+ || VECTOR_INTEGER_TYPE_P (TREE_TYPE (@1)))
&& tree_nop_conversion_p (TREE_TYPE (@2), TREE_TYPE (@0)))
(with
{
- tree arg1_type = TREE_TYPE (@1);
+ tree cst = uniform_integer_cst_p (@1);
+ tree arg1_type = TREE_TYPE (cst);
unsigned int prec = TYPE_PRECISION (arg1_type);
wide_int max = wi::max_value (arg1_type);
wide_int signed_max = wi::max_value (prec, SIGNED);
wide_int min = wi::min_value (arg1_type);
}
(switch
- (if (wi::to_wide (@1) == max)
+ (if (wi::to_wide (cst) == max)
(switch
(if (cmp == GT_EXPR)
{ constant_boolean_node (false, type); })
{ constant_boolean_node (true, type); })
(if (cmp == LT_EXPR)
(ne @2 @1))))
- (if (wi::to_wide (@1) == min)
+ (if (wi::to_wide (cst) == min)
(switch
(if (cmp == LT_EXPR)
{ constant_boolean_node (false, type); })
{ constant_boolean_node (true, type); })
(if (cmp == GT_EXPR)
(ne @2 @1))))
- (if (wi::to_wide (@1) == max - 1)
+ (if (wi::to_wide (cst) == max - 1)
(switch
(if (cmp == GT_EXPR)
- (eq @2 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) + 1); }))
+ (eq @2 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst)
+ + 1)); }))
(if (cmp == LE_EXPR)
- (ne @2 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) + 1); }))))
- (if (wi::to_wide (@1) == min + 1)
+ (ne @2 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst)
+ + 1)); }))))
+ (if (wi::to_wide (cst) == min + 1)
(switch
(if (cmp == GE_EXPR)
- (ne @2 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) - 1); }))
+ (ne @2 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst)
+ - 1)); }))
(if (cmp == LT_EXPR)
- (eq @2 { wide_int_to_tree (TREE_TYPE (@1), wi::to_wide (@1) - 1); }))))
- (if (wi::to_wide (@1) == signed_max
+ (eq @2 { build_uniform_cst (TREE_TYPE (@1),
+ wide_int_to_tree (TREE_TYPE (cst),
+ wi::to_wide (cst)
+ - 1)); }))))
+ (if (wi::to_wide (cst) == signed_max
&& TYPE_UNSIGNED (arg1_type)
/* We will flip the signedness of the comparison operator
associated with the mode of @1, so the sign bit is
/* The following case also applies to X < signed_max+1
and X >= signed_max+1 because previous transformations. */
(if (cmp == LE_EXPR || cmp == GT_EXPR)
- (with { tree st = signed_type_for (arg1_type); }
- (if (cmp == LE_EXPR)
- (ge (convert:st @0) { build_zero_cst (st); })
- (lt (convert:st @0) { build_zero_cst (st); }))))))))))
+ (with { tree st = signed_type_for (TREE_TYPE (@1)); }
+ (switch
+ (if (cst == @1 && cmp == LE_EXPR)
+ (ge (convert:st @0) { build_zero_cst (st); }))
+ (if (cst == @1 && cmp == GT_EXPR)
+ (lt (convert:st @0) { build_zero_cst (st); }))
+ (if (cmp == LE_EXPR)
+ (ge (view_convert:st @0) { build_zero_cst (st); }))
+ (if (cmp == GT_EXPR)
+ (lt (view_convert:st @0) { build_zero_cst (st); })))))))))))
(for cmp (unordered ordered unlt unle ungt unge uneq ltgt)
/* If the second operand is NaN, the result is constant. */
2018-11-29 Jakub Jelinek <jakub@redhat.com>
+ PR target/88152
+ * g++.dg/tree-ssa/pr88152-1.C: New test.
+ * g++.dg/tree-ssa/pr88152-2.C: New test.
+
PR target/88234
* gcc.dg/ubsan/pr88234.c: New test.
--- /dev/null
+// PR target/88152
+// { dg-do compile }
+// { dg-options "-O2 -std=c++14 -fdump-tree-forwprop1" }
+// { dg-final { scan-tree-dump-times " (?:<|>=) \{ 0\[, ]" 120 "forwprop1" } }
+
+template <typename T, int N>
+using V [[gnu::vector_size (sizeof (T) * N)]] = T;
+
+void *foo ();
+
+template <typename T, int N, T max, T maxp1>
+__attribute__((noipa)) void
+test_uns ()
+{
+ V<T, N> *x = (V<T, N> *) foo ();
+ x[1] = x[0] > max;
+ x[3] = x[2] >= maxp1;
+ x[5] = x[4] <= max;
+ x[7] = x[6] < maxp1;
+}
+
+template <typename T, int N>
+__attribute__((noipa)) void
+test ()
+{
+ V<T, N> *x = (V<T, N> *) foo ();
+ x[1] = x[0] >= 0;
+ x[3] = x[2] > -1;
+ x[5] = x[4] < 0;
+ x[7] = x[6] <= -1;
+}
+
+template <int N>
+__attribute__((noipa)) void
+tests ()
+{
+ test_uns<unsigned char, N, __SCHAR_MAX__, 1U + __SCHAR_MAX__> ();
+ test<signed char, N> ();
+ test_uns<unsigned short int, N, __SHRT_MAX__, 1U + __SHRT_MAX__> ();
+ test<short int, N> ();
+ test_uns<unsigned int, N, __INT_MAX__, 1U + __INT_MAX__> ();
+ test<int, N> ();
+ test_uns<unsigned long int, N, __LONG_MAX__, 1UL + __LONG_MAX__> ();
+ test<long int, N> ();
+ test_uns<unsigned long long int, N, __LONG_LONG_MAX__, 1ULL + __LONG_LONG_MAX__> ();
+ test<long long int, N> ();
+}
+
+void
+all_tests ()
+{
+ tests<1> ();
+ tests<2> ();
+ tests<8> ();
+}
--- /dev/null
+// PR target/88152
+// { dg-do compile { target int32 } }
+// { dg-options "-O2 -Wno-psabi -fdump-tree-forwprop1" }
+// { dg-final { scan-tree-dump-not " (?:>|>=|<|<=) \{ 214748364\[67]" "forwprop1" } }
+// { dg-final { scan-tree-dump-not " (?:>|>=|<|<=) \{ -214748364\[78]" "forwprop1" } }
+// { dg-final { scan-tree-dump-times "(?:return| =) \{ 0, 0, 0, 0 \}" 2 "forwprop1" } }
+// { dg-final { scan-tree-dump-times "(?:return| =) \{ -1, -1, -1, -1 \}" 2 "forwprop1" } }
+// { dg-final { scan-tree-dump-times " == \{ 2147483647, 2147483647, 2147483647, 2147483647 \}" 2 "forwprop1" } }
+// { dg-final { scan-tree-dump-times " != \{ 2147483647, 2147483647, 2147483647, 2147483647 \}" 2 "forwprop1" } }
+// { dg-final { scan-tree-dump-times " == \{ -2147483648, -2147483648, -2147483648, -2147483648 \}" 2 "forwprop1" } }
+// { dg-final { scan-tree-dump-times " != \{ -2147483648, -2147483648, -2147483648, -2147483648 \}" 2 "forwprop1" } }
+
+typedef int V __attribute__((vector_size (16)));
+
+V
+f1 (V a)
+{
+ return a > __INT_MAX__;
+}
+
+V
+f2 (V a)
+{
+ return a >= __INT_MAX__;
+}
+
+V
+f3 (V a)
+{
+ return a < __INT_MAX__;
+}
+
+V
+f4 (V a)
+{
+ return a <= __INT_MAX__;
+}
+
+V
+f5 (V a)
+{
+ return a > -__INT_MAX__ - 1;
+}
+
+V
+f6 (V a)
+{
+ return a >= -__INT_MAX__ - 1;
+}
+
+V
+f7 (V a)
+{
+ return a < -__INT_MAX__ - 1;
+}
+
+V
+f8 (V a)
+{
+ return a <= -__INT_MAX__ - 1;
+}
+
+V
+f9 (V a)
+{
+ return a > __INT_MAX__ - 1;
+}
+
+V
+f10 (V a)
+{
+ return a <= __INT_MAX__ - 1;
+}
+
+V
+f11 (V a)
+{
+ return a >= -__INT_MAX__;
+}
+
+V
+f12 (V a)
+{
+ return a < -__INT_MAX__;
+}
}
}
+/* If TYPE is not a vector type, just return SC, otherwise return
+ build_vector_from_val (TYPE, SC). */
+
+tree
+build_uniform_cst (tree type, tree sc)
+{
+ if (!VECTOR_TYPE_P (type))
+ return sc;
+
+ return build_vector_from_val (type, sc);
+}
+
/* Build a vector series of type TYPE in which element I has the value
BASE + I * STEP. The result is a constant if BASE and STEP are constant
and a VEC_SERIES_EXPR otherwise. */
return NULL_TREE;
}
+/* If the argument is INTEGER_CST, return it. If the argument is vector
+ with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
+ return NULL_TREE. */
+
+tree
+uniform_integer_cst_p (tree t)
+{
+ if (TREE_CODE (t) == INTEGER_CST)
+ return t;
+
+ if (VECTOR_TYPE_P (TREE_TYPE (t)))
+ {
+ t = uniform_vector_p (t);
+ if (t && TREE_CODE (t) == INTEGER_CST)
+ return t;
+ }
+
+ return NULL_TREE;
+}
+
/* Build an empty statement at location LOC. */
tree
extern tree make_vector (unsigned, unsigned CXX_MEM_STAT_INFO);
extern tree build_vector_from_ctor (tree, vec<constructor_elt, va_gc> *);
extern tree build_vector_from_val (tree, tree);
+extern tree build_uniform_cst (tree, tree);
extern tree build_vec_series (tree, tree, tree);
extern tree build_index_vector (tree, poly_uint64, poly_uint64);
extern void recompute_constructor_flags (tree);
extern tree uniform_vector_p (const_tree);
+/* If the argument is INTEGER_CST, return it. If the argument is vector
+ with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
+ return NULL_TREE. */
+
+extern tree uniform_integer_cst_p (tree);
+
/* Given a CONSTRUCTOR CTOR, return the element values as a vector. */
extern vec<tree, va_gc> *ctor_to_vec (tree);
projects / gcc.git / commitdiff