fold-const.c (optimize_bit_field_compare): Remove extra fold call.

2005-08-16  James A. Morrison  <phython@gcc.gnu.org>

        * fold-const.c (optimize_bit_field_compare): Remove extra fold call.
        (try_move_mult_to_index): Call fold_build2 instead of build2.
        (fold_binary): Don't call fold after calls to try_move_mult_to_index.
        * tree-ssa-loop-niter.c (inverse): Call int_const_binop instead of
        fold_binary_to_constant.
        (infer_loop_bounds_from_undefined): Call fold_build2 instead of
        fold (build.
        * tree-data-ref.c (tree_fold_divides_p): Use tree_int_cst_equal to
        check if A == gcd (A, B).  Remove TYPE argument.
        (analyze_offset) Use fold_build2 instead of fold (build.
        (create_data_ref): Likewise.
        (analyze_siv_subscript_cst_affine): Update calls to tree_fold_divides_p.        * tree-ssa-ccp.c (widen_bitfield): Call fold_build2 instead of build2
        then fold.

From-SVN: r103200

gcc/ChangeLog

+2005-08-16  James A. Morrison  <phython@gcc.gnu.org>
+
+	* fold-const.c (optimize_bit_field_compare): Remove extra fold call.
+	(try_move_mult_to_index): Call fold_build2 instead of build2.
+	(fold_binary): Don't call fold after calls to try_move_mult_to_index.
+	* tree-ssa-loop-niter.c (inverse): Call int_const_binop instead of
+	fold_binary_to_constant.
+	(infer_loop_bounds_from_undefined): Call fold_build2 instead of
+	fold (build.
+	* tree-data-ref.c (tree_fold_divides_p): Use tree_int_cst_equal to
+	check if A == gcd (A, B).  Remove TYPE argument.
+	(analyze_offset) Use fold_build2 instead of fold (build.
+	(create_data_ref): Likewise.
+	(analyze_siv_subscript_cst_affine): Update calls to tree_fold_divides_p.
+	* tree-ssa-ccp.c (widen_bitfield): Call fold_build2 instead of build2
+	then fold.
+
 2005-08-17  Kelley Cook  <kcook@gcc.gnu.org>
 
 	* config/arm/unaligned-funcs.c,config/i386/crtfastmath.c,

gcc/fold-const.c

@@ -3340,11 +3340,11 @@ optimize_bit_field_compare (enum tree_code code, tree compare_type,
       TREE_THIS_VOLATILE (lhs) = 1;
     }
 
-  rhs = fold (const_binop (BIT_AND_EXPR,
-			   const_binop (LSHIFT_EXPR,
-					fold_convert (unsigned_type, rhs),
-					size_int (lbitpos), 0),
-			   mask, 0));
+  rhs = const_binop (BIT_AND_EXPR,
+		     const_binop (LSHIFT_EXPR,
+				  fold_convert (unsigned_type, rhs),
+				  size_int (lbitpos), 0),
+		     mask, 0);
 
   return build2 (code, compare_type,
 		 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
@@ -6468,7 +6468,7 @@ try_move_mult_to_index (enum tree_code code, tree addr, tree op1)
 						     TREE_OPERAND (pos, 1)),
 				       fold_convert (itype, delta));
 
-  return build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
+  return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
 }
 
 
@@ -7305,13 +7305,13 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
 	    {
 	      tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
 	      if (tem)
-		return fold_convert (type, fold (tem));
+		return fold_convert (type, tem);
 	    }
 	  else if (TREE_CODE (arg1) == ADDR_EXPR)
 	    {
 	      tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
 	      if (tem)
-		return fold_convert (type, fold (tem));
+		return fold_convert (type, tem);
 	    }
 	}
       else
@@ -7730,7 +7730,7 @@ fold_binary (enum tree_code code, tree type, tree op0, tree op1)
 	{
 	  tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
 	  if (tem)
-	    return fold_convert (type, fold (tem));
+	    return fold_convert (type, tem);
 	}
 
       if (flag_unsafe_math_optimizations

gcc/tree-data-ref.c

@@ -479,13 +479,11 @@ base_addr_differ_p (struct data_reference *dra,
 /* Returns true iff A divides B.  */
 
 static inline bool 
-tree_fold_divides_p (tree type, 
-		     tree a, 
+tree_fold_divides_p (tree a, 
 		     tree b)
 {
   /* Determines whether (A == gcd (A, B)).  */
-  return integer_zerop 
-    (fold_build2 (MINUS_EXPR, type, a, tree_fold_gcd (a, b)));
+  return tree_int_cst_equal (a, tree_fold_gcd (a, b));
 }
 
 /* Compute the greatest common denominator of two numbers using
@@ -1723,7 +1721,7 @@ analyze_offset (tree offset, tree *invariant, tree *constant)
   *constant = constant_0 ? constant_0 : constant_1;
   if (invariant_0 && invariant_1)
     *invariant = 
-      fold (build (code, TREE_TYPE (invariant_0), invariant_0, invariant_1));
+      fold_build2 (code, TREE_TYPE (invariant_0), invariant_0, invariant_1);
   else
     *invariant = invariant_0 ? invariant_0 : invariant_1;
 }
@@ -1805,8 +1803,8 @@ create_data_ref (tree memref, tree stmt, bool is_read)
       if (constant)
 	{
 	  DR_INIT (dr) = fold_convert (ssizetype, constant);
-	  init_cond = fold (build (TRUNC_DIV_EXPR, TREE_TYPE (constant), 
-				   constant, type_size));
+	  init_cond = fold_build2 (TRUNC_DIV_EXPR, TREE_TYPE (constant), 
+				   constant, type_size);
 	}
       else
 	DR_INIT (dr) = init_cond = ssize_int (0);;
@@ -2186,8 +2184,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		     chrec_b = {10, +, 1}
 		  */
 		  
-		  if (tree_fold_divides_p 
-		      (integer_type_node, CHREC_RIGHT (chrec_b), difference))
+		  if (tree_fold_divides_p (CHREC_RIGHT (chrec_b), difference))
 		    {
 		      *overlaps_a = integer_zero_node;
 		      *overlaps_b = fold_build2 (EXACT_DIV_EXPR, integer_type_node,
@@ -2199,7 +2196,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		      return;
 		    }
 		  
-		  /* When the step does not divides the difference, there are
+		  /* When the step does not divide the difference, there are
 		     no overlaps.  */
 		  else
 		    {
@@ -2241,13 +2238,12 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
 		     chrec_a = 3
 		     chrec_b = {10, +, -1}
 		  */
-		  if (tree_fold_divides_p 
-		      (integer_type_node, CHREC_RIGHT (chrec_b), difference))
+		  if (tree_fold_divides_p (CHREC_RIGHT (chrec_b), difference))
 		    {
 		      *overlaps_a = integer_zero_node;
-		      *overlaps_b = fold 
-			(build (EXACT_DIV_EXPR, integer_type_node, difference, 
-				CHREC_RIGHT (chrec_b)));
+		      *overlaps_b = fold_build2 (EXACT_DIV_EXPR,
+				      		 integer_type_node, difference, 
+						 CHREC_RIGHT (chrec_b));
 		      *last_conflicts = integer_one_node;
 		      return;
 		    }
@@ -2816,7 +2812,7 @@ chrec_steps_divide_constant_p (tree chrec,
   switch (TREE_CODE (chrec))
     {
     case POLYNOMIAL_CHREC:
-      return (tree_fold_divides_p (integer_type_node, CHREC_RIGHT (chrec), cst)
+      return (tree_fold_divides_p (CHREC_RIGHT (chrec), cst)
 	      && chrec_steps_divide_constant_p (CHREC_LEFT (chrec), cst));
       
     default:

gcc/tree-ssa-ccp.c

@@ -1432,8 +1432,8 @@ widen_bitfield (tree val, tree field, tree var)
       for (i = 0, mask = 0; i < field_size; i++)
 	mask |= ((HOST_WIDE_INT) 1) << i;
 
-      wide_val = build2 (BIT_AND_EXPR, TREE_TYPE (var), val, 
-			 build_int_cst (TREE_TYPE (var), mask));
+      wide_val = fold_build2 (BIT_AND_EXPR, TREE_TYPE (var), val, 
+			      build_int_cst (TREE_TYPE (var), mask));
     }
   else
     {
@@ -1443,11 +1443,11 @@ widen_bitfield (tree val, tree field, tree var)
       for (i = 0, mask = 0; i < (var_size - field_size); i++)
 	mask |= ((HOST_WIDE_INT) 1) << (var_size - i - 1);
 
-      wide_val = build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
-			 build_int_cst (TREE_TYPE (var), mask));
+      wide_val = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (var), val,
+			      build_int_cst (TREE_TYPE (var), mask));
     }
 
-  return fold (wide_val);
+  return wide_val;
 }
 
 

gcc/tree-ssa-loop-niter.c

@@ -117,10 +117,10 @@ inverse (tree x, tree mask)
       rslt = build_int_cst_type (type, 1);
       for (; ctr; ctr--)
 	{
-	  rslt = fold_binary_to_constant (MULT_EXPR, type, rslt, x);
-	  x = fold_binary_to_constant (MULT_EXPR, type, x, x);
+	  rslt = int_const_binop (MULT_EXPR, rslt, x, 0);
+	  x = int_const_binop (MULT_EXPR, x, x, 0);
 	}
-      rslt = fold_binary_to_constant (BIT_AND_EXPR, type, rslt, mask);
+      rslt = int_const_binop (BIT_AND_EXPR, rslt, mask, 0);
     }
 
   return rslt;
@@ -1465,14 +1465,14 @@ infer_loop_bounds_from_undefined (struct loop *loop)
 
 		    utype = unsigned_type_for (type);
 		    if (tree_int_cst_lt (step, integer_zero_node))
-		      diff = fold (build2 (MINUS_EXPR, utype, init,
-					   TYPE_MIN_VALUE (type)));
+		      diff = fold_build2 (MINUS_EXPR, utype, init,
+					  TYPE_MIN_VALUE (type));
 		    else
-		      diff = fold (build2 (MINUS_EXPR, utype,
-					   TYPE_MAX_VALUE (type), init));
+		      diff = fold_build2 (MINUS_EXPR, utype,
+					  TYPE_MAX_VALUE (type), init);
 
-		    estimation = fold (build2 (CEIL_DIV_EXPR, utype, diff,
-					       step));
+		    estimation = fold_build2 (CEIL_DIV_EXPR, utype, diff,
+					      step);
 		    record_estimate (loop, estimation, boolean_true_node, stmt);
 		  }