* tree.h (force_fit_type_double): Remove unused final argument.

	* c-common.c (constant_expression_warning): Replace use of
	TREE_CONSTANT_OVERFLOW with TREE_OVERFLOW.
	(convert_and_check): Likewise.
	(shorten_compare): Update call to force_fit_type_double.
	(c_common_truthvalue_conversion) <INTEGER_CST>: Use integer_zerop.
	* convert.c (convert_to_pointer): Update call to
	force_fit_type_double.
	* fold-const.c (force_fit_type_double): Remove overflowed_const
	argument.
	(int_const_binop, fold_convert_const_int_from_int,
	fold_convert_const_int_from_real, fold_div_compare,
	fold_sign_changed_comparison, fold_unary, fold_negate_const,
	fold_abs_const, fold_not_const): Remove the final argument from
	calls to force_fit_type_double.

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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a346e2c..17baae3 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2007-01-12  Roger Sayle  <roger@eyesopen.com>
+
+       * tree.h (force_fit_type_double): Remove unused final argument.
+       * c-common.c (constant_expression_warning): Replace use of
+       TREE_CONSTANT_OVERFLOW with TREE_OVERFLOW.
+       (convert_and_check): Likewise.
+       (shorten_compare): Update call to force_fit_type_double.
+       (c_common_truthvalue_conversion) <INTEGER_CST>: Use integer_zerop.
+       * convert.c (convert_to_pointer): Update call to
+       force_fit_type_double.
+       * fold-const.c (force_fit_type_double): Remove overflowed_const
+       argument.
+       (int_const_binop, fold_convert_const_int_from_int,
+       fold_convert_const_int_from_real, fold_div_compare,
+       fold_sign_changed_comparison, fold_unary, fold_negate_const,
+       fold_abs_const, fold_not_const): Remove the final argument from
+       calls to force_fit_type_double.
+
 2007-01-12  Andrew Pinski  <andrew_pinski@playstation.sony.com>
 
        * configure.ac: Set insn to "nop" for spu-*-* also.

diff --git a/gcc/c-common.c b/gcc/c-common.c
index 217228d..4b1718c 100644 (file)
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -918,7 +918,7 @@ constant_expression_warning (tree value)
   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
        || TREE_CODE (value) == VECTOR_CST
        || TREE_CODE (value) == COMPLEX_CST)
-      && TREE_CONSTANT_OVERFLOW (value)
+      && TREE_OVERFLOW (value)
       && warn_overflow
       && pedantic)
     pedwarn ("overflow in constant expression");
@@ -1257,11 +1257,8 @@ convert_and_check (tree type, tree expr)
       /* Do not diagnose overflow in a constant expression merely
          because a conversion overflowed.  */
       if (TREE_OVERFLOW (result))
-        {
-          TREE_CONSTANT_OVERFLOW (result) = TREE_CONSTANT_OVERFLOW (expr);
-          TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
-        }
-      
+        TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
+
       if (TYPE_UNSIGNED (type))
         {
           /* This detects cases like converting -129 or 256 to
@@ -2323,8 +2320,7 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
          primop1 = force_fit_type_double (*restype_ptr,
                                           TREE_INT_CST_LOW (primop1),
                                           TREE_INT_CST_HIGH (primop1), 0,
-                                          TREE_OVERFLOW (primop1),
-                                          TREE_CONSTANT_OVERFLOW (primop1));
+                                          TREE_OVERFLOW (primop1));
        }
       if (type != *restype_ptr)
        {
@@ -2685,10 +2681,8 @@ c_common_truthvalue_conversion (tree expr)
       return expr;
 
     case INTEGER_CST:
-      /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW.  */
-      return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
-            ? truthvalue_true_node
-            : truthvalue_false_node;
+      return integer_zerop (expr) ? truthvalue_false_node
+                                 : truthvalue_true_node;
 
     case REAL_CST:
       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)

diff --git a/gcc/convert.c b/gcc/convert.c
index 771401e..b7d26ee 100644 (file)
--- a/gcc/convert.c
+++ b/gcc/convert.c
@@ -47,8 +47,7 @@ convert_to_pointer (tree type, tree expr)
 
   /* Propagate overflow to the NULL pointer.  */
   if (integer_zerop (expr))
-    return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr),
-                                 false);
+    return force_fit_type_double (type, 0, 0, 0, TREE_OVERFLOW (expr));
 
   switch (TREE_CODE (TREE_TYPE (expr)))
     {

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 3a3fe36..2ae560f 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1,6 +1,7 @@
 /* Fold a constant sub-tree into a single node for C-compiler
    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -28,7 +29,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
   @@ for cross-compilers.  */
 
 /* The entry points in this file are fold, size_int_wide, size_binop
-   and force_fit_type.
+   and force_fit_type_double.
 
    fold takes a tree as argument and returns a simplified tree.
 
@@ -39,10 +40,10 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
    size_int takes an integer value, and creates a tree constant
    with type from `sizetype'.
 
-   force_fit_type takes a constant, an overflowable flag and prior
-   overflow indicators.  It forces the value to fit the type and sets
-   TREE_OVERFLOW as appropriate.
-   
+   force_fit_type_double takes a constant, an overflowable flag and a
+   prior overflow indicator.  It forces the value to fit the type and
+   sets TREE_OVERFLOW.
+
    Note: Since the folders get called on non-gimple code as well as
    gimple code, we need to handle GIMPLE tuples as well as their
    corresponding tree equivalents.  */
@@ -281,7 +282,7 @@ fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
 tree
 force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
                       HOST_WIDE_INT high, int overflowable,
-                      bool overflowed, bool overflowed_const)
+                      bool overflowed)
 {
   int sign_extended_type;
   bool overflow;
@@ -294,7 +295,7 @@ force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
   overflow = fit_double_type (low, high, &low, &high, type);
 
   /* If we need to set overflow flags, return a new unshared node.  */
-  if (overflowed || overflowed_const || overflow)
+  if (overflowed || overflow)
     {
       if (overflowed
          || overflowable < 0
@@ -1607,8 +1608,7 @@ int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
   else
     t = force_fit_type_double (TREE_TYPE (arg1), low, hi, 1,
                               ((!uns || is_sizetype) && overflow)
-                              | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2),
-                              false);
+                              | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
 
   return t;
 }
@@ -1884,8 +1884,7 @@ fold_convert_const_int_from_int (tree type, tree arg1)
                             (TREE_INT_CST_HIGH (arg1) < 0
                              && (TYPE_UNSIGNED (type)
                                  < TYPE_UNSIGNED (TREE_TYPE (arg1))))
-                            | TREE_OVERFLOW (arg1),
-                            false);
+                            | TREE_OVERFLOW (arg1));
 
   return t;
 }
@@ -1964,8 +1963,7 @@ fold_convert_const_int_from_real (enum tree_code code, tree type, tree arg1)
     REAL_VALUE_TO_INT (&low, &high, r);
 
   t = force_fit_type_double (type, low, high, -1,
-                            overflow | TREE_OVERFLOW (arg1),
-                            false);
+                            overflow | TREE_OVERFLOW (arg1));
   return t;
 }
 
@@ -6143,7 +6141,7 @@ fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
                                   TREE_INT_CST_HIGH (arg1),
                                   &lpart, &hpart, unsigned_p);
   prod = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
-                               -1, overflow, false);
+                               -1, overflow);
   neg_overflow = false;
 
   if (unsigned_p)
@@ -6159,8 +6157,7 @@ fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
                                       TREE_INT_CST_HIGH (tmp),
                                       &lpart, &hpart, unsigned_p);
       hi = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
-                                 -1, overflow | TREE_OVERFLOW (prod),
-                                 false);
+                                 -1, overflow | TREE_OVERFLOW (prod));
     }
   else if (tree_int_cst_sgn (arg01) >= 0)
     {
@@ -6596,8 +6593,7 @@ fold_sign_changed_comparison (enum tree_code code, tree type,
   if (TREE_CODE (arg1) == INTEGER_CST)
     arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
                                  TREE_INT_CST_HIGH (arg1), 0,
-                                 TREE_OVERFLOW (arg1),
-                                 false);
+                                 TREE_OVERFLOW (arg1));
   else
     arg1 = fold_convert (inner_type, arg1);
 
@@ -7531,8 +7527,7 @@ fold_unary (enum tree_code code, tree type, tree op0)
            {
              tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
                                           TREE_INT_CST_HIGH (and1), 0,
-                                          TREE_OVERFLOW (and1),
-                                          false);
+                                          TREE_OVERFLOW (and1));
              return fold_build2 (BIT_AND_EXPR, type,
                                  fold_convert (type, and0), tem);
            }
@@ -13045,8 +13040,7 @@ fold_negate_const (tree arg0, tree type)
                                   &low, &high);
        t = force_fit_type_double (type, low, high, 1,
                                   (overflow | TREE_OVERFLOW (arg0))
-                                  && !TYPE_UNSIGNED (type),
-                                  false);
+                                  && !TYPE_UNSIGNED (type));
        break;
       }
 
@@ -13091,8 +13085,7 @@ fold_abs_const (tree arg0, tree type)
                                     TREE_INT_CST_HIGH (arg0),
                                     &low, &high);
          t = force_fit_type_double (type, low, high, -1,
-                                    overflow | TREE_OVERFLOW (arg0),
-                                    false);
+                                    overflow | TREE_OVERFLOW (arg0));
        }
       break;
 
@@ -13122,8 +13115,7 @@ fold_not_const (tree arg0, tree type)
 
   t = force_fit_type_double (type, ~TREE_INT_CST_LOW (arg0),
                             ~TREE_INT_CST_HIGH (arg0), 0,
-                            TREE_OVERFLOW (arg0),
-                            false);
+                            TREE_OVERFLOW (arg0));
 
   return t;
 }

diff --git a/gcc/tree.h b/gcc/tree.h
index 6ba24ab..cbb47cc 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -1,6 +1,6 @@
 /* Front-end tree definitions for GNU compiler.
    Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
-   2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+   2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -4315,7 +4315,7 @@ extern tree fold_abs_const (tree, tree);
 extern tree fold_indirect_ref_1 (tree, tree);
 
 extern tree force_fit_type_double (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT,
-                                  int, bool, bool);
+                                  int, bool);
 
 extern int fit_double_type (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
                            unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, tree);