* tree-chrec.c (avoid_arithmetics_in_type_p): New.

	(convert_affine_scev, chrec_convert_aggressive): Use
	avoid_arithmetics_in_type_p.  Do not check for the subtypes
	separately.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@115528 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 24 insertions, 21 deletions

diff --git a/gcc/tree-chrec.c b/gcc/tree-chrec.c
index 8038b12279d..f9b804e6177 100644
--- a/gcc/tree-chrec.c
+++ b/gcc/tree-chrec.c
@@ -1096,6 +1096,21 @@ nb_vars_in_chrec (tree chrec)
     }
 }
 
+/* Returns true if TYPE is a type in that we cannot directly perform
+   arithmetics, even though it is a scalar type.  */
+
+static bool
+avoid_arithmetics_in_type_p (tree type)
+{
+  /* Ada frontend uses subtypes -- an arithmetic cannot be directly performed
+     in the subtype, but a base type must be used, and the result then can
+     be casted to the subtype.  */
+  if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
+    return true;
+
+  return false;
+}
+
 static tree chrec_convert_1 (tree, tree, tree, bool);
 
 /* Converts BASE and STEP of affine scev to TYPE.  LOOP is the loop whose iv
@@ -1116,6 +1131,10 @@ convert_affine_scev (struct loop *loop, tree type,
   bool must_check_src_overflow, must_check_rslt_overflow;
   tree new_base, new_step;
 
+  /* If we cannot perform arithmetic in TYPE, avoid creating an scev.  */
+  if (avoid_arithmetics_in_type_p (type))
+    return false;
+
   /* In general,
      (TYPE) (BASE + STEP * i) = (TYPE) BASE + (TYPE -- sign extend) STEP * i,
      but we must check some assumptions.
@@ -1305,6 +1324,10 @@ chrec_convert_aggressive (tree type, tree chrec)
   if (TYPE_PRECISION (type) > TYPE_PRECISION (inner_type))
     return NULL_TREE;
 
+  /* If we cannot perform arithmetic in TYPE, avoid creating an scev.  */
+  if (avoid_arithmetics_in_type_p (type))
+    return false;
+
   left = CHREC_LEFT (chrec);
   right = CHREC_RIGHT (chrec);
   lc = chrec_convert_aggressive (type, left);
@@ -1313,27 +1336,7 @@ chrec_convert_aggressive (tree type, tree chrec)
   rc = chrec_convert_aggressive (type, right);
   if (!rc)
     rc = chrec_convert (type, right, NULL_TREE);
-
-  /* Ada creates sub-types where TYPE_MIN_VALUE/TYPE_MAX_VALUE do not
-     cover the entire range of values allowed by TYPE_PRECISION.
-
-     We do not want to optimize away conversions to such types.  Long
-     term I'd rather see the Ada front-end fixed.  */
-  if (INTEGRAL_TYPE_P (type))
-    {
-      tree t;
-
-      t = upper_bound_in_type (type, inner_type);
-      if (! TYPE_MAX_VALUE (type)
-	  || ! operand_equal_p (TYPE_MAX_VALUE (type), t, 0))
-	return NULL_TREE;
-
-      t = lower_bound_in_type (type, inner_type);
-      if (! TYPE_MIN_VALUE (type)
-	  || ! operand_equal_p (TYPE_MIN_VALUE (type), t, 0))
-	return NULL_TREE;
-    }
-  
+ 
   return build_polynomial_chrec (CHREC_VARIABLE (chrec), lc, rc);
 }