tree-vrp.c (build_assert_expr_for, [...]): Use buildN instead of build.

2005-12-02  Richard Guenther  <rguenther@suse.de>

	* tree-vrp.c (build_assert_expr_for, process_assert_insertions_for,
	simplify_cond_using_ranges): Use buildN instead of build.
	* tree-tailcall.c (adjust_accumulator_values,
	adjust_return_value): Likewise.
	* tree-sra.c (generate_one_element_ref, generate_copy_inout,
	generate_element_copy, generate_element_zero,
	generate_one_element_init): Likewise.
	* tree-ssa-forwprop.c (forward_propagate_into_cond_1): Likewise.
	* lambda-code.c (gcc_loop_to_lambda_loop, lbv_to_gcc_expression,
	lle_to_gcc_expression, lambda_loopnest_to_gcc_loopnest,
	perfect_nestify): Likewise.

From-SVN: r107894

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b0f57b08377c554d223f13861e46e2e046d52d4f..0f20adc6b4a6ba0d237e803e5e97fb5150e3efba 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,17 @@
+2005-12-02  Richard Guenther  <rguenther@suse.de>
+
+       * tree-vrp.c (build_assert_expr_for, process_assert_insertions_for,
+       simplify_cond_using_ranges): Use buildN instead of build.
+       * tree-tailcall.c (adjust_accumulator_values,
+       adjust_return_value): Likewise.
+       * tree-sra.c (generate_one_element_ref, generate_copy_inout,
+       generate_element_copy, generate_element_zero,
+       generate_one_element_init): Likewise.
+       * tree-ssa-forwprop.c (forward_propagate_into_cond_1): Likewise.
+       * lambda-code.c (gcc_loop_to_lambda_loop, lbv_to_gcc_expression,
+       lle_to_gcc_expression, lambda_loopnest_to_gcc_loopnest,
+       perfect_nestify): Likewise.
+
 2005-12-02  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>
 
        * pa.c (pa_secondary_reload): Revise initialization of variable regno.

diff --git a/gcc/lambda-code.c b/gcc/lambda-code.c
index 2d6db22cced618966110299d70e848a4b678fde3..43889f78595cb3e81a2929d0894326783d185fd5 100644 (file)
--- a/gcc/lambda-code.c
+++ b/gcc/lambda-code.c
@@ -1434,8 +1434,8 @@ gcc_loop_to_lambda_loop (struct loop *loop, int depth,
   ubound = gcc_tree_to_linear_expression (depth, uboundvar,
                                          outerinductionvars,
                                          *invariants, extra);
-  uboundresult = build (PLUS_EXPR, TREE_TYPE (uboundvar), uboundvar,
-                       build_int_cst (TREE_TYPE (uboundvar), extra));
+  uboundresult = build2 (PLUS_EXPR, TREE_TYPE (uboundvar), uboundvar,
+                        build_int_cst (TREE_TYPE (uboundvar), extra));
   VEC_safe_push (tree, heap, *uboundvars, uboundresult);
   VEC_safe_push (tree, heap, *lboundvars, lboundvar);
   VEC_safe_push (int, heap, *steps, stepint);
@@ -1576,7 +1576,7 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
   add_referenced_tmp_var (resvar);
 
   /* Start at 0.  */
-  stmt = build (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+  stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
   name = make_ssa_name (resvar, stmt);
   TREE_OPERAND (stmt, 0) = name;
   tsi = tsi_last (stmts);
@@ -1591,8 +1591,8 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
          
          /* newname = coefficient * induction_variable */
          coeffmult = build_int_cst (type, LBV_COEFFICIENTS (lbv)[i]);
-         stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                       fold_build2 (MULT_EXPR, type, iv, coeffmult));
+         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                        fold_build2 (MULT_EXPR, type, iv, coeffmult));
 
          newname = make_ssa_name (resvar, stmt);
          TREE_OPERAND (stmt, 0) = newname;
@@ -1601,8 +1601,8 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
          tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
          /* name = name + newname */
-         stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                       build (PLUS_EXPR, type, name, newname));
+         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                        build2 (PLUS_EXPR, type, name, newname));
          name = make_ssa_name (resvar, stmt);
          TREE_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
@@ -1616,8 +1616,8 @@ lbv_to_gcc_expression (lambda_body_vector lbv,
   if (LBV_DENOMINATOR (lbv) != 1)
     {
       tree denominator = build_int_cst (type, LBV_DENOMINATOR (lbv));
-      stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                   build (CEIL_DIV_EXPR, type, name, denominator));
+      stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                    build2 (CEIL_DIV_EXPR, type, name, denominator));
       name = make_ssa_name (resvar, stmt);
       TREE_OPERAND (stmt, 0) = name;
       fold_stmt (&stmt);
@@ -1667,7 +1667,7 @@ lle_to_gcc_expression (lambda_linear_expression lle,
   for (; lle != NULL; lle = LLE_NEXT (lle))
     {
       /* Start at name = 0.  */
-      stmt = build (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
+      stmt = build2 (MODIFY_EXPR, void_type_node, resvar, integer_zero_node);
       name = make_ssa_name (resvar, stmt);
       TREE_OPERAND (stmt, 0) = name;
       fold_stmt (&stmt);
@@ -1698,7 +1698,7 @@ lle_to_gcc_expression (lambda_linear_expression lle,
                }
 
              /* newname = mult */
-             stmt = build (MODIFY_EXPR, void_type_node, resvar, mult);
+             stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
              newname = make_ssa_name (resvar, stmt);
              TREE_OPERAND (stmt, 0) = newname;
              fold_stmt (&stmt);
@@ -1706,8 +1706,8 @@ lle_to_gcc_expression (lambda_linear_expression lle,
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
              /* name = name + newname */
-             stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                           build (PLUS_EXPR, type, name, newname));
+             stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                            build2 (PLUS_EXPR, type, name, newname));
              name = make_ssa_name (resvar, stmt);
              TREE_OPERAND (stmt, 0) = name;
              fold_stmt (&stmt);
@@ -1739,7 +1739,7 @@ lle_to_gcc_expression (lambda_linear_expression lle,
                }
 
              /* newname = mult */
-             stmt = build (MODIFY_EXPR, void_type_node, resvar, mult);
+             stmt = build2 (MODIFY_EXPR, void_type_node, resvar, mult);
              newname = make_ssa_name (resvar, stmt);
              TREE_OPERAND (stmt, 0) = newname;
              fold_stmt (&stmt);
@@ -1747,8 +1747,8 @@ lle_to_gcc_expression (lambda_linear_expression lle,
              tsi_link_after (&tsi, stmt, TSI_CONTINUE_LINKING);
 
              /* name = name + newname */
-             stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                           build (PLUS_EXPR, type, name, newname));
+             stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                            build2 (PLUS_EXPR, type, name, newname));
              name = make_ssa_name (resvar, stmt);
              TREE_OPERAND (stmt, 0) = name;
              fold_stmt (&stmt);
@@ -1761,9 +1761,9 @@ lle_to_gcc_expression (lambda_linear_expression lle,
          name = name + constant.  */
       if (LLE_CONSTANT (lle) != 0)
        {
-         stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                       build (PLUS_EXPR, type, name, 
-                              build_int_cst (type, LLE_CONSTANT (lle))));
+         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                        build2 (PLUS_EXPR, type, name, 
+                                build_int_cst (type, LLE_CONSTANT (lle))));
          name = make_ssa_name (resvar, stmt);
          TREE_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
@@ -1775,9 +1775,9 @@ lle_to_gcc_expression (lambda_linear_expression lle,
          name = name + linear offset.  */
       if (LLE_CONSTANT (offset) != 0)
        {
-         stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                       build (PLUS_EXPR, type, name, 
-                              build_int_cst (type, LLE_CONSTANT (offset))));
+         stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                        build2 (PLUS_EXPR, type, name, 
+                                build_int_cst (type, LLE_CONSTANT (offset))));
          name = make_ssa_name (resvar, stmt);
          TREE_OPERAND (stmt, 0) = name;
          fold_stmt (&stmt);
@@ -1789,9 +1789,9 @@ lle_to_gcc_expression (lambda_linear_expression lle,
       if (LLE_DENOMINATOR (lle) != 1)
        {
          stmt = build_int_cst (type, LLE_DENOMINATOR (lle));
-         stmt = build (wrap == MAX_EXPR ? CEIL_DIV_EXPR : FLOOR_DIV_EXPR,
-                       type, name, stmt);
-         stmt = build (MODIFY_EXPR, void_type_node, resvar, stmt);
+         stmt = build2 (wrap == MAX_EXPR ? CEIL_DIV_EXPR : FLOOR_DIV_EXPR,
+                        type, name, stmt);
+         stmt = build2 (MODIFY_EXPR, void_type_node, resvar, stmt);
 
          /* name = {ceil, floor}(name/denominator) */
          name = make_ssa_name (resvar, stmt);
@@ -1811,8 +1811,8 @@ lle_to_gcc_expression (lambda_linear_expression lle,
     {
       tree op1 = VEC_index (tree, results, 0);
       tree op2 = VEC_index (tree, results, 1);
-      stmt = build (MODIFY_EXPR, void_type_node, resvar,
-                   build (wrap, type, op1, op2));
+      stmt = build2 (MODIFY_EXPR, void_type_node, resvar,
+                    build2 (wrap, type, op1, op2));
       name = make_ssa_name (resvar, stmt);
       TREE_OPERAND (stmt, 0) = name;
       tsi = tsi_last (stmts);
@@ -1927,10 +1927,10 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
         dominate the block containing the exit condition.
         So we simply create our own incremented iv to use in the new exit
         test,  and let redundancy elimination sort it out.  */
-      inc_stmt = build (PLUS_EXPR, type, 
-                       ivvar, build_int_cst (type, LL_STEP (newloop)));
-      inc_stmt = build (MODIFY_EXPR, void_type_node, SSA_NAME_VAR (ivvar),
-                       inc_stmt);
+      inc_stmt = build2 (PLUS_EXPR, type, 
+                        ivvar, build_int_cst (type, LL_STEP (newloop)));
+      inc_stmt = build2 (MODIFY_EXPR, void_type_node, SSA_NAME_VAR (ivvar),
+                        inc_stmt);
       ivvarinced = make_ssa_name (SSA_NAME_VAR (ivvar), inc_stmt);
       TREE_OPERAND (inc_stmt, 0) = ivvarinced;
       bsi = bsi_for_stmt (exitcond);
@@ -1948,9 +1948,9 @@ lambda_loopnest_to_gcc_loopnest (struct loop *old_loopnest,
       if (exit->flags & EDGE_FALSE_VALUE)
        testtype = swap_tree_comparison (testtype);
 
-      COND_EXPR_COND (exitcond) = build (testtype,
-                                        boolean_type_node,
-                                        newupperbound, ivvarinced);
+      COND_EXPR_COND (exitcond) = build2 (testtype,
+                                         boolean_type_node,
+                                         newupperbound, ivvarinced);
       update_stmt (exitcond);
       VEC_replace (tree, new_ivs, i, ivvar);
 
@@ -2424,11 +2424,11 @@ perfect_nestify (struct loops *loops,
   make_edge (headerbb, bodybb, EDGE_FALLTHRU); 
   then_label = build1 (GOTO_EXPR, void_type_node, tree_block_label (latchbb));
   else_label = build1 (GOTO_EXPR, void_type_node, tree_block_label (olddest));
-  cond_stmt = build (COND_EXPR, void_type_node,
-                    build (NE_EXPR, boolean_type_node, 
-                           integer_one_node, 
-                           integer_zero_node), 
-                    then_label, else_label);
+  cond_stmt = build3 (COND_EXPR, void_type_node,
+                     build2 (NE_EXPR, boolean_type_node, 
+                             integer_one_node, 
+                             integer_zero_node), 
+                     then_label, else_label);
   bsi = bsi_start (bodybb);
   bsi_insert_after (&bsi, cond_stmt, BSI_NEW_STMT);
   e = make_edge (bodybb, olddest, EDGE_FALSE_VALUE);
@@ -2464,8 +2464,8 @@ perfect_nestify (struct loops *loops,
   exit_condition = get_loop_exit_condition (newloop);
   uboundvar = create_tmp_var (integer_type_node, "uboundvar");
   add_referenced_tmp_var (uboundvar);
-  stmt = build (MODIFY_EXPR, void_type_node, uboundvar, 
-               VEC_index (tree, ubounds, 0));
+  stmt = build2 (MODIFY_EXPR, void_type_node, uboundvar, 
+                VEC_index (tree, ubounds, 0));
   uboundvar = make_ssa_name (uboundvar, stmt);
   TREE_OPERAND (stmt, 0) = uboundvar;
 
@@ -2474,10 +2474,10 @@ perfect_nestify (struct loops *loops,
   else
     bsi_insert_before (&bsi, stmt, BSI_SAME_STMT);
   update_stmt (stmt);
-  COND_EXPR_COND (exit_condition) = build (GE_EXPR, 
-                                          boolean_type_node,
-                                          uboundvar,
-                                          ivvarinced);
+  COND_EXPR_COND (exit_condition) = build2 (GE_EXPR, 
+                                           boolean_type_node,
+                                           uboundvar,
+                                           ivvarinced);
   update_stmt (exit_condition);
   bbs = get_loop_body_in_dom_order (loop); 
   /* Now move the statements, and replace the induction variable in the moved

diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index c25632020ea55c2276550ea73779b74171a7d5b0..bae96f0c2209bf66951082c33752c225d8e0e575 100644 (file)
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -1511,17 +1511,17 @@ generate_one_element_ref (struct sra_elt *elt, tree base)
        if (DECL_FIELD_CONTEXT (field) != TYPE_MAIN_VARIANT (TREE_TYPE (base)))
          field = find_compatible_field (TREE_TYPE (base), field);
 
-        return build (COMPONENT_REF, elt->type, base, field, NULL);
+        return build3 (COMPONENT_REF, elt->type, base, field, NULL);
       }
 
     case ARRAY_TYPE:
-      return build (ARRAY_REF, elt->type, base, elt->element, NULL, NULL);
+      return build4 (ARRAY_REF, elt->type, base, elt->element, NULL, NULL);
 
     case COMPLEX_TYPE:
       if (elt->element == integer_zero_node)
-       return build (REALPART_EXPR, elt->type, base);
+       return build1 (REALPART_EXPR, elt->type, base);
       else
-       return build (IMAGPART_EXPR, elt->type, base);
+       return build1 (IMAGPART_EXPR, elt->type, base);
 
     default:
       gcc_unreachable ();
@@ -1561,17 +1561,17 @@ generate_copy_inout (struct sra_elt *elt, bool copy_out, tree expr,
       c = lookup_element (elt, integer_one_node, NULL, NO_INSERT);
       i = c->replacement;
 
-      t = build (COMPLEX_EXPR, elt->type, r, i);
-      t = build (MODIFY_EXPR, void_type_node, expr, t);
+      t = build2 (COMPLEX_EXPR, elt->type, r, i);
+      t = build2 (MODIFY_EXPR, void_type_node, expr, t);
       SSA_NAME_DEF_STMT (expr) = t;
       append_to_statement_list (t, list_p);
     }
   else if (elt->replacement)
     {
       if (copy_out)
-       t = build (MODIFY_EXPR, void_type_node, elt->replacement, expr);
+       t = build2 (MODIFY_EXPR, void_type_node, elt->replacement, expr);
       else
-       t = build (MODIFY_EXPR, void_type_node, expr, elt->replacement);
+       t = build2 (MODIFY_EXPR, void_type_node, expr, elt->replacement);
       append_to_statement_list (t, list_p);
     }
   else
@@ -1606,8 +1606,8 @@ generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
 
       gcc_assert (src->replacement);
 
-      t = build (MODIFY_EXPR, void_type_node, dst->replacement,
-                src->replacement);
+      t = build2 (MODIFY_EXPR, void_type_node, dst->replacement,
+                 src->replacement);
       append_to_statement_list (t, list_p);
     }
 }
@@ -1638,7 +1638,7 @@ generate_element_zero (struct sra_elt *elt, tree *list_p)
       gcc_assert (elt->is_scalar);
       t = fold_convert (elt->type, integer_zero_node);
 
-      t = build (MODIFY_EXPR, void_type_node, elt->replacement, t);
+      t = build2 (MODIFY_EXPR, void_type_node, elt->replacement, t);
       append_to_statement_list (t, list_p);
     }
 }
@@ -1650,7 +1650,7 @@ static void
 generate_one_element_init (tree var, tree init, tree *list_p)
 {
   /* The replacement can be almost arbitrarily complex.  Gimplify.  */
-  tree stmt = build (MODIFY_EXPR, void_type_node, var, init);
+  tree stmt = build2 (MODIFY_EXPR, void_type_node, var, init);
   gimplify_and_add (stmt, list_p);
 }
 

diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index 8618ce745e33ab3516c9835d9fcc987854db022e..a5023ed810c9dd01e50ecb84adc07898027d85e4 100644 (file)
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -244,7 +244,7 @@ forward_propagate_into_cond_1 (tree cond, tree *test_var_p)
          if (!is_gimple_val (t))
            return NULL_TREE;
 
-         new_cond = build (cond_code, boolean_type_node, op0, t);
+         new_cond = build2 (cond_code, boolean_type_node, op0, t);
        }
     }
 
@@ -285,8 +285,8 @@ forward_propagate_into_cond_1 (tree cond, tree *test_var_p)
          if (has_single_use (test_var))
            {
              /* TEST_VAR was set from a relational operator.  */
-             new_cond = build (TREE_CODE (def_rhs),
-                               boolean_type_node, op0, op1);
+             new_cond = build2 (TREE_CODE (def_rhs),
+                                boolean_type_node, op0, op1);
 
              /* Invert the conditional if necessary.  */
              if ((cond_code == EQ_EXPR

diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c
index 7d510af778225cb7645d945976a2d59c09f1467f..ce5af15ef1c7c0838750856654bf8b11f4f261b1 100644 (file)
--- a/gcc/tree-tailcall.c
+++ b/gcc/tree-tailcall.c
@@ -559,8 +559,8 @@ adjust_accumulator_values (block_stmt_iterator bsi, tree m, tree a, edge back)
            var = m_acc;
          else
            {
-             stmt = build (MODIFY_EXPR, ret_type, NULL_TREE,
-                           build (MULT_EXPR, ret_type, m_acc, a));
+             stmt = build2 (MODIFY_EXPR, ret_type, NULL_TREE,
+                            build2 (MULT_EXPR, ret_type, m_acc, a));
 
              tmp = create_tmp_var (ret_type, "acc_tmp");
              add_referenced_tmp_var (tmp);
@@ -573,8 +573,8 @@ adjust_accumulator_values (block_stmt_iterator bsi, tree m, tree a, edge back)
       else
        var = a;
 
-      stmt = build (MODIFY_EXPR, ret_type, NULL_TREE,
-                   build (PLUS_EXPR, ret_type, a_acc, var));
+      stmt = build2 (MODIFY_EXPR, ret_type, NULL_TREE,
+                    build2 (PLUS_EXPR, ret_type, a_acc, var));
       var = make_ssa_name (SSA_NAME_VAR (a_acc), stmt);
       TREE_OPERAND (stmt, 0) = var;
       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
@@ -583,8 +583,8 @@ adjust_accumulator_values (block_stmt_iterator bsi, tree m, tree a, edge back)
 
   if (m)
     {
-      stmt = build (MODIFY_EXPR, ret_type, NULL_TREE,
-                   build (MULT_EXPR, ret_type, m_acc, m));
+      stmt = build2 (MODIFY_EXPR, ret_type, NULL_TREE,
+                    build2 (MULT_EXPR, ret_type, m_acc, m));
       var = make_ssa_name (SSA_NAME_VAR (m_acc), stmt);
       TREE_OPERAND (stmt, 0) = var;
       bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
@@ -638,8 +638,8 @@ adjust_return_value (basic_block bb, tree m, tree a)
 
   if (m)
     {
-      stmt = build (MODIFY_EXPR, ret_type, NULL_TREE,
-                   build (MULT_EXPR, ret_type, m_acc, ret_var));
+      stmt = build2 (MODIFY_EXPR, ret_type, NULL_TREE,
+                    build2 (MULT_EXPR, ret_type, m_acc, ret_var));
 
       tmp = create_tmp_var (ret_type, "acc_tmp");
       add_referenced_tmp_var (tmp);
@@ -653,8 +653,8 @@ adjust_return_value (basic_block bb, tree m, tree a)
 
   if (a)
     {
-      stmt = build (MODIFY_EXPR, ret_type, NULL_TREE,
-                   build (PLUS_EXPR, ret_type, a_acc, var));
+      stmt = build2 (MODIFY_EXPR, ret_type, NULL_TREE,
+                    build2 (PLUS_EXPR, ret_type, a_acc, var));
 
       tmp = create_tmp_var (ret_type, "acc_tmp");
       add_referenced_tmp_var (tmp);

diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 0797b5c028a4705b3b35b9d068d9843ee28bbe2b..04353f5ad8b279c2889b4c93acf1f58e2fe6452b 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -2164,21 +2164,21 @@ build_assert_expr_for (tree cond, tree v)
 
   if (COMPARISON_CLASS_P (cond))
     {
-      tree a = build (ASSERT_EXPR, TREE_TYPE (v), v, cond); 
-      assertion = build (MODIFY_EXPR, TREE_TYPE (v), n, a);
+      tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond); 
+      assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, a);
     }
   else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
     {
       /* Given !V, build the assignment N = false.  */
       tree op0 = TREE_OPERAND (cond, 0);
       gcc_assert (op0 == v);
-      assertion = build (MODIFY_EXPR, TREE_TYPE (v), n, boolean_false_node);
+      assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_false_node);
     }
   else if (TREE_CODE (cond) == SSA_NAME)
     {
       /* Given V, build the assignment N = true.  */
       gcc_assert (v == cond);
-      assertion = build (MODIFY_EXPR, TREE_TYPE (v), n, boolean_true_node);
+      assertion = build2 (MODIFY_EXPR, TREE_TYPE (v), n, boolean_true_node);
     }
   else
     gcc_unreachable ();
@@ -2781,7 +2781,7 @@ process_assert_insertions_for (tree name, assert_locus_t loc)
   edge_iterator ei;
   edge e;
 
-  cond = build (loc->comp_code, boolean_type_node, name, loc->val);
+  cond = build2 (loc->comp_code, boolean_type_node, name, loc->val);
   assert_expr = build_assert_expr_for (cond, name);
 
   if (loc->e)
@@ -3957,7 +3957,7 @@ simplify_cond_using_ranges (tree stmt)
                }
 
              COND_EXPR_COND (stmt)
-               = build (EQ_EXPR, boolean_type_node, op0, new);
+               = build2 (EQ_EXPR, boolean_type_node, op0, new);
              update_stmt (stmt);
 
              if (dump_file)
@@ -3985,7 +3985,7 @@ simplify_cond_using_ranges (tree stmt)
                }
 
              COND_EXPR_COND (stmt)
-               = build (NE_EXPR, boolean_type_node, op0, new);
+               = build2 (NE_EXPR, boolean_type_node, op0, new);
              update_stmt (stmt);
 
              if (dump_file)