scev/niter: Use INTEGRAL_NB_TYPE_P instead of direct comparison to INTEGER_TYPE [PR124061]

I noticed this while looking into PR 124052. This is not the first time we had
direct type comparison against INTEGER_TYPE which should have been different.
As mention in PR 124052, I didn't include bool types so I needed a new macro
to simplify things.

Bootstrapped and tested on x86_64-linux-gnu.

	PR tree-optimization/124061

gcc/ChangeLog:

	* tree-scalar-evolution.cc (interpret_rhs_expr): Use
	INTEGRAL_NB_TYPE_P instead of comparing the code to INTEGER_TYPE.
	* tree-ssa-loop-niter.cc (number_of_iterations_ne): Likewise.
	(number_of_iterations_cltz): Likewise.
	(number_of_iterations_exit_assumptions): Likewise.
	* tree.h (INTEGRAL_NB_TYPE_P): New macro.

gcc/testsuite/ChangeLog:

	* g++.dg/opt/enum-loop-1.C: New test.
	* gcc.dg/tree-ssa/bitint-loop-opt-1.c: New test.

Signed-off-by: Andrew Pinski <andrew.pinski@oss.qualcomm.com>

Author: pinskia

gcc/testsuite/g++.dg/opt/enum-loop-1.C

@@ -0,0 +1,15 @@
+// PR tree-optimization/124061
+// { dg-do compile { target c++11 } }
+// { dg-options "-O2 -fdump-tree-sccp" }
+
+enum a : unsigned {};
+
+int f(a limit)
+{
+  a i;
+  for(i = (a)0; i < limit; i = a(i + 1))
+   ;
+  return i;
+}
+
+// { dg-final { scan-tree-dump "final value replacement:"  sccp } }

gcc/testsuite/gcc.dg/tree-ssa/bitint-loop-opt-1.c

@@ -0,0 +1,13 @@
+/* PR tree-optimization/124061 */
+/* { dg-do compile { target bitint } } */
+/* { dg-options "-O2 -fdump-tree-sccp" } */
+
+int f(_BitInt(64) limit)
+{
+  _BitInt(64) i;
+  for(i = 0; i < limit; i++)
+   ;
+  return i;
+}
+
+/* { dg-final { scan-tree-dump "final value replacement:"  sccp } } */

gcc/tree-scalar-evolution.cc

@@ -1897,8 +1897,8 @@ interpret_rhs_expr (class loop *loop, gimple *at_stmt,
 	 the operation done in an unsigned type of the same precision
 	 as the final truncation.  We cannot derive a scalar evolution
 	 for the widened operation but for the truncated result.  */
-      if (TREE_CODE (type) == INTEGER_TYPE
-	  && TREE_CODE (TREE_TYPE (rhs1)) == INTEGER_TYPE
+      if (INTEGRAL_NB_TYPE_P (type)
+	  && INTEGRAL_NB_TYPE_P (TREE_TYPE (rhs1))
 	  && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (rhs1))
 	  && TYPE_OVERFLOW_UNDEFINED (type)
 	  && TREE_CODE (rhs1) == SSA_NAME

gcc/tree-ssa-loop-niter.cc

@@ -1054,7 +1054,7 @@ number_of_iterations_ne (class loop *loop, tree type, affine_iv *iv,
       if (tree_int_cst_sign_bit (iv->step))
 	{
 	  cond = fold_build2 (GE_EXPR, boolean_type_node, iv->base, final);
-	  if (TREE_CODE (type) == INTEGER_TYPE)
+	  if (INTEGRAL_NB_TYPE_P (type))
 	    {
 	      /* Only when base - step doesn't overflow.  */
 	      t = TYPE_MAX_VALUE (type);
@@ -1071,7 +1071,7 @@ number_of_iterations_ne (class loop *loop, tree type, affine_iv *iv,
       else
 	{
 	  cond = fold_build2 (LE_EXPR, boolean_type_node, iv->base, final);
-	  if (TREE_CODE (type) == INTEGER_TYPE)
+	  if (INTEGRAL_NB_TYPE_P (type))
 	    {
 	      /* Only when base - step doesn't underflow.  */
 	      t = TYPE_MIN_VALUE (type);
@@ -2439,7 +2439,7 @@ number_of_iterations_cltz (loop_p loop, edge exit,
 	  iv_2 = gimple_assign_rhs1 (test_value_stmt);
 	  tree rhs_type = TREE_TYPE (iv_2);
 	  if (TREE_CODE (iv_2) != SSA_NAME
-	      || TREE_CODE (rhs_type) != INTEGER_TYPE
+	      || !INTEGRAL_NB_TYPE_P (rhs_type)
 	      || (TYPE_PRECISION (rhs_type)
 		  != TYPE_PRECISION (test_value_type)))
 	    return false;
@@ -3275,7 +3275,7 @@ number_of_iterations_exit_assumptions (class loop *loop, edge exit,
   op1 = gimple_cond_rhs (stmt);
   type = TREE_TYPE (op0);
 
-  if (TREE_CODE (type) != INTEGER_TYPE
+  if (!INTEGRAL_NB_TYPE_P (type)
       && !POINTER_TYPE_P (type))
     return false;
 

gcc/tree.h

@@ -617,6 +617,13 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
    || TREE_CODE (TYPE) == INTEGER_TYPE \
    || TREE_CODE (TYPE) == BITINT_TYPE)
 
+/* Nonzero if TYPE represents an integral type (non-boolean).  */
+
+#define INTEGRAL_NB_TYPE_P(TYPE)  \
+  (TREE_CODE (TYPE) == ENUMERAL_TYPE  \
+   || TREE_CODE (TYPE) == INTEGER_TYPE \
+   || TREE_CODE (TYPE) == BITINT_TYPE)
+
 /* Nonzero if TYPE represents an integral type, including complex
    and vector integer types.  */