fold-const.c (combine_comparisons, [...]): Use constant_boolean_node where appropriate.

	* fold-const.c (combine_comparisons, optimize_bit_field_compare,
	range_binop, fold_truthop, fold_binary_op_with_conditional_arg,
	fold_mathfn_compare, fold_inf_compare, fold,
	fold_relational_hi_lo, nondestructive_fold_binary_to_constant):
	Use constant_boolean_node where appropriate.  Don't bother using
	fold_convert on the second argument to omit_one_operand.

From-SVN: r82468

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 7ea891993b3610f3a5bbec53c5420294f46d87a9..0746702b562242d8f7f5693e0875825e09f4a3d9 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2004-05-30  Roger Sayle  <roger@eyesopen.com>
+
+       * fold-const.c (combine_comparisons, optimize_bit_field_compare,
+       range_binop, fold_truthop, fold_binary_op_with_conditional_arg,
+       fold_mathfn_compare, fold_inf_compare, fold,
+       fold_relational_hi_lo, nondestructive_fold_binary_to_constant):
+       Use constant_boolean_node where appropriate.  Don't bother using
+       fold_convert on the second argument to omit_one_operand.
+
 2004-05-30  Roger Sayle  <roger@eyesopen.com>
 
        * doc/c-tree.texi (Expressions): Document FLOOR_DIV_EXPR,

diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 7445408ce52aa7cd0a6d4620dde0e3a361a66dcc..d2e333e0d42e14821dd04363182bcde2ffadade6 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -2298,9 +2298,9 @@ combine_comparisons (enum tree_code code, enum tree_code lcode,
       }
 
   if (compcode == COMPCODE_TRUE)
-    return fold_convert (truth_type, integer_one_node);
+    return constant_boolean_node (true, truth_type);
   else if (compcode == COMPCODE_FALSE)
-    return fold_convert (truth_type, integer_zero_node);
+    return constant_boolean_node (false, truth_type);
   else
     return fold (build2 (compcode_to_comparison (compcode),
                         truth_type, ll_arg, lr_arg));
@@ -3141,9 +3141,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
        {
          warning ("comparison is always %d due to width of bit-field",
                   code == NE_EXPR);
-         return fold_convert (compare_type,
-                              (code == NE_EXPR
-                               ? integer_one_node : integer_zero_node));
+         return constant_boolean_node (code == NE_EXPR, compare_type);
        }
     }
   else
@@ -3154,9 +3152,7 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
        {
          warning ("comparison is always %d due to width of bit-field",
                   code == NE_EXPR);
-         return fold_convert (compare_type,
-                              (code == NE_EXPR
-                               ? integer_one_node : integer_zero_node));
+         return constant_boolean_node (code == NE_EXPR, compare_type);
        }
     }
 
@@ -3479,7 +3475,7 @@ range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
       abort ();
     }
 
-  return fold_convert (type, result ? integer_one_node : integer_zero_node);
+  return constant_boolean_node (result, type);
 }
 \f
 /* Given EXP, a logical expression, set the range it is testing into
@@ -4212,7 +4208,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
        return build2 (NE_EXPR, truth_type,
                       build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
                               ll_arg, rl_arg),
-                      integer_zero_node);
+                      fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
 
       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
       if (code == TRUTH_AND_EXPR
@@ -4222,7 +4218,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
        return build2 (EQ_EXPR, truth_type,
                       build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
                               ll_arg, rl_arg),
-                      integer_zero_node);
+                      fold_convert (TREE_TYPE (ll_arg), integer_zero_node));
 
       return build2 (code, truth_type, lhs, rhs);
     }
@@ -4344,9 +4340,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
        {
          warning ("comparison is always %d", wanted_code == NE_EXPR);
 
-         return fold_convert (truth_type,
-                              wanted_code == NE_EXPR
-                              ? integer_one_node : integer_zero_node);
+         return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
        }
     }
   if (r_const)
@@ -4361,9 +4355,7 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
        {
          warning ("comparison is always %d", wanted_code == NE_EXPR);
 
-         return fold_convert (truth_type,
-                              wanted_code == NE_EXPR
-                              ? integer_one_node : integer_zero_node);
+         return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
        }
     }
 
@@ -4491,12 +4483,12 @@ fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
       if (wanted_code == NE_EXPR)
        {
          warning ("`or' of unmatched not-equal tests is always 1");
-         return fold_convert (truth_type, integer_one_node);
+         return constant_boolean_node (true, truth_type);
        }
       else
        {
          warning ("`and' of mutually exclusive equal-tests is always 0");
-         return fold_convert (truth_type, integer_zero_node);
+         return constant_boolean_node (false, truth_type);
        }
     }
 
@@ -4973,8 +4965,8 @@ fold_binary_op_with_conditional_arg (enum tree_code code, tree type,
     {
       tree testtype = TREE_TYPE (cond);
       test = cond;
-      true_value = fold_convert (testtype, integer_one_node);
-      false_value = fold_convert (testtype, integer_zero_node);
+      true_value = constant_boolean_node (true, testtype);
+      false_value = constant_boolean_node (false, testtype);
     }
 
   if (lhs == 0)
@@ -5054,16 +5046,12 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
        {
          /* sqrt(x) < y is always false, if y is negative.  */
          if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_zero_node),
-                                    arg);
+           return omit_one_operand (type, integer_zero_node, arg);
 
          /* sqrt(x) > y is always true, if y is negative and we
             don't care about NaNs, i.e. negative values of x.  */
          if (code == NE_EXPR || !HONOR_NANS (mode))
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_one_node),
-                                    arg);
+           return omit_one_operand (type, integer_one_node, arg);
 
          /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
          return fold (build2 (GE_EXPR, type, arg,
@@ -5085,9 +5073,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
 
              /* sqrt(x) > y is always false, when y is very large
                 and we don't care about infinities.  */
-             return omit_one_operand (type,
-                                      fold_convert (type, integer_zero_node),
-                                      arg);
+             return omit_one_operand (type, integer_zero_node, arg);
            }
 
          /* sqrt(x) > c is the same as x > c*c.  */
@@ -5106,9 +5092,7 @@ fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
              /* sqrt(x) < y is always true, when y is a very large
                 value and we don't care about NaNs or Infinities.  */
              if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
-               return omit_one_operand (type,
-                                        fold_convert (type, integer_one_node),
-                                        arg);
+               return omit_one_operand (type, integer_one_node, arg);
 
              /* sqrt(x) < y is x != +Inf when y is very large and we
                 don't care about NaNs.  */
@@ -5192,16 +5176,12 @@ fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
       /* x > +Inf is always false, if with ignore sNANs.  */
       if (HONOR_SNANS (mode))
         return NULL_TREE;
-      return omit_one_operand (type,
-                              fold_convert (type, integer_zero_node),
-                              arg0);
+      return omit_one_operand (type, integer_zero_node, arg0);
 
     case LE_EXPR:
       /* x <= +Inf is always true, if we don't case about NaNs.  */
       if (! HONOR_NANS (mode))
-       return omit_one_operand (type,
-                                fold_convert (type, integer_one_node),
-                                arg0);
+       return omit_one_operand (type, integer_one_node, arg0);
 
       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
       if (lang_hooks.decls.global_bindings_p () == 0
@@ -7380,12 +7360,7 @@ fold (tree expr)
          && DECL_P (TREE_OPERAND (arg0, 0))
          && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
          && integer_zerop (arg1))
-       {
-         if (code == EQ_EXPR)
-           return fold_convert (type, integer_zero_node);
-         else
-           return fold_convert (type, integer_one_node);
-       }
+       return constant_boolean_node (code != EQ_EXPR, type);
 
       /* If this is an equality comparison of the address of two non-weak,
         unaliased symbols neither of which are extern (since we do not
@@ -7403,14 +7378,9 @@ fold (tree expr)
          && ! lookup_attribute ("alias",
                                 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
          && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
-       {
-         if (code == EQ_EXPR)
-           return fold_convert (type, (operand_equal_p (arg0, arg1, 0)
-                   ? integer_one_node : integer_zero_node));
-         else
-           return fold_convert (type, (operand_equal_p (arg0, arg1, 0)
-                   ? integer_zero_node : integer_one_node));
-       }
+       return constant_boolean_node (operand_equal_p (arg0, arg1, 0)
+                                     ? code == EQ_EXPR : code != EQ_EXPR,
+                                     type);
 
       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
        {
@@ -7456,7 +7426,7 @@ fold (tree expr)
                && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
              {
                tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
-               return omit_one_operand (type, fold_convert (type, tem), arg0);
+               return omit_one_operand (type, tem, arg0);
              }
 
            /* Fold comparisons against infinity.  */
@@ -7632,18 +7602,14 @@ fold (tree expr)
              switch (code)
                {
                case GT_EXPR:
-                 return omit_one_operand (type,
-                                          fold_convert (type,
-                                                        integer_zero_node),
-                                          arg0);
+                 return omit_one_operand (type, integer_zero_node, arg0);
+
                case GE_EXPR:
                  return fold (build2 (EQ_EXPR, type, arg0, arg1));
 
                case LE_EXPR:
-                 return omit_one_operand (type,
-                                          fold_convert (type,
-                                                        integer_one_node),
-                                          arg0);
+                 return omit_one_operand (type, integer_one_node, arg0);
+
                case LT_EXPR:
                  return fold (build2 (NE_EXPR, type, arg0, arg1));
 
@@ -7671,18 +7637,14 @@ fold (tree expr)
              switch (code)
                {
                case LT_EXPR:
-                 return omit_one_operand (type,
-                                          fold_convert (type,
-                                                        integer_zero_node),
-                                          arg0);
+                 return omit_one_operand (type, integer_zero_node, arg0);
+
                case LE_EXPR:
                  return fold (build2 (EQ_EXPR, type, arg0, arg1));
 
                case GE_EXPR:
-                 return omit_one_operand (type,
-                                          fold_convert (type,
-                                                        integer_one_node),
-                                          arg0);
+                 return omit_one_operand (type, integer_one_node, arg0);
+
                case GT_EXPR:
                  return fold (build2 (NE_EXPR, type, arg0, arg1));
 
@@ -9316,16 +9278,14 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
        switch (code)
          {
          case GT_EXPR:
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_zero_node),
-                                    op0);
+           return omit_one_operand (type, integer_zero_node, op0);
+
          case GE_EXPR:
            *code_p = EQ_EXPR;
            break;
          case LE_EXPR:
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_one_node),
-                                    op0);
+           return omit_one_operand (type, integer_one_node, op0);
+
          case LT_EXPR:
            *code_p = NE_EXPR;
            break;
@@ -9356,17 +9316,15 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
        switch (code)
          {
          case LT_EXPR:
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_zero_node),
-                                    op0);
+           return omit_one_operand (type, integer_zero_node, op0);
+
          case LE_EXPR:
            *code_p = EQ_EXPR;
            break;
 
          case GE_EXPR:
-           return omit_one_operand (type,
-                                    fold_convert (type, integer_one_node),
-                                    op0);
+           return omit_one_operand (type, integer_one_node, op0);
+
          case GT_EXPR:
            *code_p = NE_EXPR;
            break;
@@ -9686,12 +9644,7 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
       if (integer_zerop (op0))
        return omit_one_operand (type, op0, op1);
       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
-       {
-         int x1 = ! integer_zerop (op0);
-         int x2 = ! integer_zerop (op1);
-
-         return ((x1 & x2) ? integer_one_node : integer_zero_node);
-       }
+       return constant_boolean_node (true, type);
       return NULL_TREE;
 
     case TRUTH_OR_EXPR:
@@ -9704,21 +9657,14 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
       if (TREE_CODE (op0) == INTEGER_CST && ! integer_zerop (op0))
        return omit_one_operand (type, op0, op1);
       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
-       {
-         int x1 = ! integer_zerop (op0);
-         int x2 = ! integer_zerop (op1);
-
-         return ((x1 | x2) ? integer_one_node : integer_zero_node);
-       }
+       return constant_boolean_node (false, type);
       return NULL_TREE;
 
     case TRUTH_XOR_EXPR:
       if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
        {
-         int x1 = ! integer_zerop (op0);
-         int x2 = ! integer_zerop (op1);
-
-         return ((x1 ^ x2) ? integer_one_node : integer_zero_node);
+         int x = ! integer_zerop (op0) ^ ! integer_zerop (op1);
+         return constant_boolean_node (x, type);
        }
       return NULL_TREE;