builtins.c (fold_builtin_int_roundingfn): Use fit_double_type.

2007-01-08  Richard Guenther  <rguenther@suse.de>

	* builtins.c (fold_builtin_int_roundingfn): Use fit_double_type.
	* tree.c (build_int_cst_type): Likewise.
	(size_in_bytes): Don't call force_fit_type on the result.
	(int_fits_type_p): Use fit_double_type.
	* fold-const.c (fit_double_type): New function.
	(force_fit_type): Use it.
	* tree.h (fit_double_type): Export.

From-SVN: r120593

1 files changed, 72 insertions, 44 deletions

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 559acf0..d082ed3 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -192,58 +192,44 @@ decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
   *hi = words[2] + words[3] * BASE;
 }
 
-/* T is an INT_CST node.  OVERFLOWABLE indicates if we are interested
-   in overflow of the value, when >0 we are only interested in signed
-   overflow, for <0 we are interested in any overflow.  OVERFLOWED
-   indicates whether overflow has already occurred.  CONST_OVERFLOWED
-   indicates whether constant overflow has already occurred.  We force
-   T's value to be within range of T's type (by setting to 0 or 1 all
-   the bits outside the type's range).  We set TREE_OVERFLOWED if,
-  	OVERFLOWED is nonzero,
-	or OVERFLOWABLE is >0 and signed overflow occurs
-	or OVERFLOWABLE is <0 and any overflow occurs
-   We set TREE_CONSTANT_OVERFLOWED if,
-        CONST_OVERFLOWED is nonzero
-	or we set TREE_OVERFLOWED.
-  We return either the original T, or a copy.  */
+/* Force the double-word integer L1, H1 to be within the range of the
+   integer type TYPE.  Stores the properly truncated and sign-extended
+   double-word integer in *LV, *HV.  Returns true if the operation
+   overflows, that is, argument and result are different.  */
 
-tree
-force_fit_type (tree t, int overflowable,
-		bool overflowed, bool overflowed_const)
+int
+fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
+		 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, tree type)
 {
-  unsigned HOST_WIDE_INT low;
-  HOST_WIDE_INT high;
+  unsigned HOST_WIDE_INT low0 = l1;
+  HOST_WIDE_INT high0 = h1;
   unsigned int prec;
   int sign_extended_type;
 
-  gcc_assert (TREE_CODE (t) == INTEGER_CST);
-
-  low = TREE_INT_CST_LOW (t);
-  high = TREE_INT_CST_HIGH (t);
-
-  if (POINTER_TYPE_P (TREE_TYPE (t))
-      || TREE_CODE (TREE_TYPE (t)) == OFFSET_TYPE)
+  if (POINTER_TYPE_P (type)
+      || TREE_CODE (type) == OFFSET_TYPE)
     prec = POINTER_SIZE;
   else
-    prec = TYPE_PRECISION (TREE_TYPE (t));
+    prec = TYPE_PRECISION (type);
+
   /* Size types *are* sign extended.  */
-  sign_extended_type = (!TYPE_UNSIGNED (TREE_TYPE (t))
-			|| (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
-			    && TYPE_IS_SIZETYPE (TREE_TYPE (t))));
+  sign_extended_type = (!TYPE_UNSIGNED (type)
+			|| (TREE_CODE (type) == INTEGER_TYPE
+			    && TYPE_IS_SIZETYPE (type)));
 
   /* First clear all bits that are beyond the type's precision.  */
-
   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
     ;
   else if (prec > HOST_BITS_PER_WIDE_INT)
-    high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
+    h1 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
   else
     {
-      high = 0;
+      h1 = 0;
       if (prec < HOST_BITS_PER_WIDE_INT)
-	low &= ~((HOST_WIDE_INT) (-1) << prec);
+	l1 &= ~((HOST_WIDE_INT) (-1) << prec);
     }
 
+  /* Then do sign extension if necessary.  */
   if (!sign_extended_type)
     /* No sign extension */;
   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
@@ -251,28 +237,70 @@ force_fit_type (tree t, int overflowable,
   else if (prec > HOST_BITS_PER_WIDE_INT)
     {
       /* Sign extend top half? */
-      if (high & ((unsigned HOST_WIDE_INT)1
-		  << (prec - HOST_BITS_PER_WIDE_INT - 1)))
-	high |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
+      if (h1 & ((unsigned HOST_WIDE_INT)1
+		<< (prec - HOST_BITS_PER_WIDE_INT - 1)))
+	h1 |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
     }
   else if (prec == HOST_BITS_PER_WIDE_INT)
     {
-      if ((HOST_WIDE_INT)low < 0)
-	high = -1;
+      if ((HOST_WIDE_INT)l1 < 0)
+	h1 = -1;
     }
   else
     {
       /* Sign extend bottom half? */
-      if (low & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
+      if (l1 & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
 	{
-	  high = -1;
-	  low |= (HOST_WIDE_INT)(-1) << prec;
+	  h1 = -1;
+	  l1 |= (HOST_WIDE_INT)(-1) << prec;
 	}
     }
 
+  *lv = l1;
+  *hv = h1;
+
+  /* If the value didn't fit, signal overflow.  */
+  return l1 != low0 || h1 != high0;
+}
+
+/* T is an INT_CST node.  OVERFLOWABLE indicates if we are interested
+   in overflow of the value, when >0 we are only interested in signed
+   overflow, for <0 we are interested in any overflow.  OVERFLOWED
+   indicates whether overflow has already occurred.  CONST_OVERFLOWED
+   indicates whether constant overflow has already occurred.  We force
+   T's value to be within range of T's type (by setting to 0 or 1 all
+   the bits outside the type's range).  We set TREE_OVERFLOWED if,
+  	OVERFLOWED is nonzero,
+	or OVERFLOWABLE is >0 and signed overflow occurs
+	or OVERFLOWABLE is <0 and any overflow occurs
+   We set TREE_CONSTANT_OVERFLOWED if,
+        CONST_OVERFLOWED is nonzero
+	or we set TREE_OVERFLOWED.
+  We return either the original T, or a copy.  */
+
+tree
+force_fit_type (tree t, int overflowable,
+		bool overflowed, bool overflowed_const)
+{
+  unsigned HOST_WIDE_INT low;
+  HOST_WIDE_INT high;
+  int sign_extended_type;
+  bool overflow;
+
+  gcc_assert (TREE_CODE (t) == INTEGER_CST);
+
+  /* Size types *are* sign extended.  */
+  sign_extended_type = (!TYPE_UNSIGNED (TREE_TYPE (t))
+			|| (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
+			    && TYPE_IS_SIZETYPE (TREE_TYPE (t))));
+
+  low = TREE_INT_CST_LOW (t);
+  high = TREE_INT_CST_HIGH (t);
+
+  overflow = fit_double_type (low, high, &low, &high, TREE_TYPE (t));
+
   /* If the value changed, return a new node.  */
-  if (overflowed || overflowed_const
-      || low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
+  if (overflowed || overflowed_const || overflow)
     {
       t = build_int_cst_wide (TREE_TYPE (t), low, high);