dojump.c: Fix comment typos.

	* dojump.c: Fix comment typos.  emit-rtl.c, expmed.c, expr.c,
	stmt.c, stor-layout.c: Use fold_buildN instead of
	fold (buildN (...)).

From-SVN: r98848

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 05686d92b95771a4e5365def5a17513844ffd2c2..717e7a18bf9141b915701ce323ce601d3148c699 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -8,6 +8,10 @@
        (init_ssanames, fini_ssa_names, make_ssanames,
        release_ssa_name): Update uses of ssa_names.
 
+       * dojump.c: Fix comment typos.  emit-rtl.c, expmed.c, expr.c,
+       stmt.c, stor-layout.c: Use fold_buildN instead of
+       fold (buildN (...)).
+
 2005-04-27  Devang Patel <dpatel@apple.com>
 
        * dbxout.c (dbxout_type): Check use_gnu_debug_info_extensions.

diff --git a/gcc/dojump.c b/gcc/dojump.c
index 3c9d88a548b9b8a4f3688da23749dfd7d4c2922a..c274a6ecff4a7772c9ac3e215e13388e1254230d 100644 (file)
--- a/gcc/dojump.c
+++ b/gcc/dojump.c
@@ -504,8 +504,8 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
            if (if_true_label == 0)
              drop_through_label = if_true_label = gen_label_rtx ();
              
-            cmp0 = fold (build2 (tcode1, TREE_TYPE (exp), op0, op1));
-            cmp1 = fold (build2 (tcode2, TREE_TYPE (exp), op0, op1));
+            cmp0 = fold_build2 (tcode1, TREE_TYPE (exp), op0, op1);
+            cmp1 = fold_build2 (tcode2, TREE_TYPE (exp), op0, op1);
            do_jump (cmp0, 0, if_true_label);
            do_jump (cmp1, if_false_label, if_true_label);
           }

diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 04107970f6428074a23bfe54f0e136b1c0d0a891..3ed2321450fda0266c2bcd27a30cca075225136e 100644 (file)
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1579,8 +1579,8 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
                 index, then convert to sizetype and multiply by the size of
                 the array element.  */
              if (! integer_zerop (low_bound))
-               index = fold (build2 (MINUS_EXPR, TREE_TYPE (index),
-                                     index, low_bound));
+               index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
+                                    index, low_bound);
 
              off_tree = size_binop (PLUS_EXPR,
                                     size_binop (MULT_EXPR, convert (sizetype,

diff --git a/gcc/expmed.c b/gcc/expmed.c
index e0ad4cffb5e5b5369bbdd90d503533f9f9d87765..c814233d24c733ebf539ebc39d8e08021a999415 100644 (file)
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -2232,9 +2232,9 @@ expand_shift (enum tree_code code, enum machine_mode mode, rtx shifted,
              tree type = TREE_TYPE (amount);
              tree new_amount = make_tree (type, op1);
              tree other_amount
-               = fold (build2 (MINUS_EXPR, type, 
-                               build_int_cst (type, GET_MODE_BITSIZE (mode)),
-                               amount));
+               = fold_build2 (MINUS_EXPR, type,
+                              build_int_cst (type, GET_MODE_BITSIZE (mode)),
+                              amount);
 
              shifted = force_reg (mode, shifted);
 
@@ -4890,23 +4890,23 @@ make_tree (tree type, rtx x)
       }
 
     case PLUS:
-      return fold (build2 (PLUS_EXPR, type, make_tree (type, XEXP (x, 0)),
-                          make_tree (type, XEXP (x, 1))));
+      return fold_build2 (PLUS_EXPR, type, make_tree (type, XEXP (x, 0)),
+                         make_tree (type, XEXP (x, 1)));
 
     case MINUS:
-      return fold (build2 (MINUS_EXPR, type, make_tree (type, XEXP (x, 0)),
-                          make_tree (type, XEXP (x, 1))));
+      return fold_build2 (MINUS_EXPR, type, make_tree (type, XEXP (x, 0)),
+                         make_tree (type, XEXP (x, 1)));
 
     case NEG:
-      return fold (build1 (NEGATE_EXPR, type, make_tree (type, XEXP (x, 0))));
+      return fold_build1 (NEGATE_EXPR, type, make_tree (type, XEXP (x, 0)));
 
     case MULT:
-      return fold (build2 (MULT_EXPR, type, make_tree (type, XEXP (x, 0)),
-                          make_tree (type, XEXP (x, 1))));
+      return fold_build2 (MULT_EXPR, type, make_tree (type, XEXP (x, 0)),
+                         make_tree (type, XEXP (x, 1)));
 
     case ASHIFT:
-      return fold (build2 (LSHIFT_EXPR, type, make_tree (type, XEXP (x, 0)),
-                          make_tree (type, XEXP (x, 1))));
+      return fold_build2 (LSHIFT_EXPR, type, make_tree (type, XEXP (x, 0)),
+                         make_tree (type, XEXP (x, 1)));
 
     case LSHIFTRT:
       t = lang_hooks.types.unsigned_type (type);
@@ -4986,11 +4986,11 @@ const_mult_add_overflow_p (rtx x, rtx mult, rtx add,
   add_type = (GET_MODE (add) == VOIDmode ? mult_type
              : lang_hooks.types.type_for_mode (GET_MODE (add), unsignedp));
 
-  result = fold (build2 (PLUS_EXPR, mult_type,
-                        fold (build2 (MULT_EXPR, mult_type,
-                                      make_tree (mult_type, x),
-                                      make_tree (mult_type, mult))),
-                        make_tree (add_type, add)));
+  result = fold_build2 (PLUS_EXPR, mult_type,
+                       fold_build2 (MULT_EXPR, mult_type,
+                                    make_tree (mult_type, x),
+                                    make_tree (mult_type, mult)),
+                       make_tree (add_type, add));
 
   return TREE_CONSTANT_OVERFLOW (result);
 }
@@ -5011,11 +5011,11 @@ expand_mult_add (rtx x, rtx target, rtx mult, rtx add, enum machine_mode mode,
   tree add_type = (GET_MODE (add) == VOIDmode
                   ? type: lang_hooks.types.type_for_mode (GET_MODE (add),
                                                           unsignedp));
-  tree result =  fold (build2 (PLUS_EXPR, type,
-                              fold (build2 (MULT_EXPR, type,
-                                            make_tree (type, x),
-                                            make_tree (type, mult))),
-                              make_tree (add_type, add)));
+  tree result = fold_build2 (PLUS_EXPR, type,
+                            fold_build2 (MULT_EXPR, type,
+                                         make_tree (type, x),
+                                         make_tree (type, mult)),
+                            make_tree (add_type, add));
 
   return expand_expr (result, target, VOIDmode, 0);
 }

diff --git a/gcc/expr.c b/gcc/expr.c
index 07e57a4fbfa58ea61bcea20faf7d007af9a512bc..25bdd0f79cef681878cd17544492d09c92a038a7 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -4783,9 +4783,9 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
                
                if (BYTES_BIG_ENDIAN)
                  value
-                   = fold (build2 (LSHIFT_EXPR, type, value,
-                                   build_int_cst (NULL_TREE,
-                                                  BITS_PER_WORD - bitsize)));
+                  = fold_build2 (LSHIFT_EXPR, type, value,
+                                  build_int_cst (NULL_TREE,
+                                                 BITS_PER_WORD - bitsize));
                bitsize = BITS_PER_WORD;
                mode = word_mode;
              }
@@ -4986,8 +4986,8 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
                    /* Assign value to element index.  */
                    position
                      = convert (ssizetype,
-                                fold (build2 (MINUS_EXPR, TREE_TYPE (index),
-                                              index, TYPE_MIN_VALUE (domain))));
+                                fold_build2 (MINUS_EXPR, TREE_TYPE (index),
+                                             index, TYPE_MIN_VALUE (domain)));
                    position = size_binop (MULT_EXPR, position,
                                           convert (ssizetype,
                                                    TYPE_SIZE_UNIT (elttype)));
@@ -5029,10 +5029,10 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size)
                
                if (minelt)
                  index = fold_convert (ssizetype,
-                                       fold (build2 (MINUS_EXPR,
-                                                     TREE_TYPE (index),
-                                                     index,
-                                                     TYPE_MIN_VALUE (domain))));
+                                       fold_build2 (MINUS_EXPR,
+                                                    TREE_TYPE (index),
+                                                    index,
+                                                    TYPE_MIN_VALUE (domain)));
                
                position = size_binop (MULT_EXPR, index,
                                       convert (ssizetype,
@@ -5485,8 +5485,8 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
               index, then convert to sizetype and multiply by the size of
               the array element.  */
            if (! integer_zerop (low_bound))
-             index = fold (build2 (MINUS_EXPR, TREE_TYPE (index),
-                                   index, low_bound));
+             index = fold_build2 (MINUS_EXPR, TREE_TYPE (index),
+                                  index, low_bound);
 
            offset = size_binop (PLUS_EXPR, offset,
                                 size_binop (MULT_EXPR,
@@ -8971,9 +8971,9 @@ try_tablejump (tree index_type, tree index_expr, tree minval, tree range,
   if (! HAVE_tablejump)
     return 0;
 
-  index_expr = fold (build2 (MINUS_EXPR, index_type,
-                            convert (index_type, index_expr),
-                            convert (index_type, minval)));
+  index_expr = fold_build2 (MINUS_EXPR, index_type,
+                           convert (index_type, index_expr),
+                           convert (index_type, minval));
   index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
   do_pending_stack_adjust ();
 

diff --git a/gcc/stmt.c b/gcc/stmt.c
index 9b685953c430a94548322e8861735e3cdce0b12d..94b018adba84eb3721d9178299503f616549de5d 100644 (file)
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -2238,10 +2238,10 @@ emit_case_bit_tests (tree index_type, tree index_expr, tree minval,
       else
         test[i].bits++;
 
-      lo = tree_low_cst (fold (build2 (MINUS_EXPR, index_type,
-                                      n->low, minval)), 1);
-      hi = tree_low_cst (fold (build2 (MINUS_EXPR, index_type,
-                                      n->high, minval)), 1);
+      lo = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
+                                     n->low, minval), 1);
+      hi = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
+                                     n->high, minval), 1);
       for (j = lo; j <= hi; j++)
         if (j >= HOST_BITS_PER_WIDE_INT)
          test[i].hi |= (HOST_WIDE_INT) 1 << (j - HOST_BITS_PER_INT);
@@ -2251,9 +2251,9 @@ emit_case_bit_tests (tree index_type, tree index_expr, tree minval,
 
   qsort (test, count, sizeof(*test), case_bit_test_cmp);
 
-  index_expr = fold (build2 (MINUS_EXPR, index_type,
-                            fold_convert (index_type, index_expr),
-                            fold_convert (index_type, minval)));
+  index_expr = fold_build2 (MINUS_EXPR, index_type,
+                           fold_convert (index_type, index_expr),
+                           fold_convert (index_type, minval));
   index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
   do_pending_stack_adjust ();
 
@@ -2417,7 +2417,7 @@ expand_case (tree exp)
        }
 
       /* Compute span of values.  */
-      range = fold (build2 (MINUS_EXPR, index_type, maxval, minval));
+      range = fold_build2 (MINUS_EXPR, index_type, maxval, minval);
 
       /* Try implementing this switch statement by a short sequence of
         bit-wise comparisons.  However, we let the binary-tree case
@@ -2543,11 +2543,11 @@ expand_case (tree exp)
                 value since that should fit in a HOST_WIDE_INT while the
                 actual values may not.  */
              HOST_WIDE_INT i_low
-               = tree_low_cst (fold (build2 (MINUS_EXPR, index_type,
-                                             n->low, minval)), 1);
+               = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
+                                            n->low, minval), 1);
              HOST_WIDE_INT i_high
-               = tree_low_cst (fold (build2 (MINUS_EXPR, index_type,
-                                             n->high, minval)), 1);
+               = tree_low_cst (fold_build2 (MINUS_EXPR, index_type,
+                                            n->high, minval), 1);
              HOST_WIDE_INT i;
 
              for (i = i_low; i <= i_high; i ++)
@@ -2828,8 +2828,8 @@ node_has_low_bound (case_node_ptr node, tree index_type)
   if (node->left)
     return 0;
 
-  low_minus_one = fold (build2 (MINUS_EXPR, TREE_TYPE (node->low),
-                               node->low, integer_one_node));
+  low_minus_one = fold_build2 (MINUS_EXPR, TREE_TYPE (node->low),
+                              node->low, integer_one_node);
 
   /* If the subtraction above overflowed, we can't verify anything.
      Otherwise, look for a parent that tests our value - 1.  */
@@ -2878,8 +2878,8 @@ node_has_high_bound (case_node_ptr node, tree index_type)
   if (node->right)
     return 0;
 
-  high_plus_one = fold (build2 (PLUS_EXPR, TREE_TYPE (node->high),
-                               node->high, integer_one_node));
+  high_plus_one = fold_build2 (PLUS_EXPR, TREE_TYPE (node->high),
+                              node->high, integer_one_node);
 
   /* If the addition above overflowed, we can't verify anything.
      Otherwise, look for a parent that tests our value + 1.  */
@@ -3303,8 +3303,8 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
              new_index = expand_simple_binop (mode, MINUS, index, low_rtx,
                                               NULL_RTX, unsignedp,
                                               OPTAB_WIDEN);
-             new_bound = expand_expr (fold (build2 (MINUS_EXPR, type,
-                                                    high, low)),
+             new_bound = expand_expr (fold_build2 (MINUS_EXPR, type,
+                                                   high, low),
                                       NULL_RTX, mode, 0);
 
              emit_cmp_and_jump_insns (new_index, new_bound, GT, NULL_RTX,

diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index b0cc42e18c6a641eb32243b5bc64cf1cc32f2299..41d316543e77a41d2a98738253a6ea00fe1cdebc 100644 (file)
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -746,9 +746,9 @@ place_union_field (record_layout_info rli, tree field)
   if (TREE_CODE (rli->t) == UNION_TYPE)
     rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field));
   else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE)
-    rli->offset = fold (build3 (COND_EXPR, sizetype,
-                               DECL_QUALIFIER (field),
-                               DECL_SIZE_UNIT (field), rli->offset));
+    rli->offset = fold_build3 (COND_EXPR, sizetype,
+                              DECL_QUALIFIER (field),
+                              DECL_SIZE_UNIT (field), rli->offset);
 }
 
 #if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED)
@@ -1641,9 +1641,9 @@ layout_type (tree type)
               that (possible) negative values are handled appropriately.  */
            length = size_binop (PLUS_EXPR, size_one_node,
                                 fold_convert (sizetype,
-                                              fold (build2 (MINUS_EXPR,
-                                                            TREE_TYPE (lb),
-                                                            ub, lb))));
+                                              fold_build2 (MINUS_EXPR,
+                                                           TREE_TYPE (lb),
+                                                           ub, lb)));
 
            /* Special handling for arrays of bits (for Chill).  */
            element_size = TYPE_SIZE (element);