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

6 files changed, 91 insertions, 77 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b0f57b0..0f20adc 100644
--- 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 2d6db22..43889f7 100644
--- 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 c256320..bae96f0 100644
--- 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 8618ce7..a5023ed 100644
--- 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 7d510af..ce5af15 100644
--- 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 0797b5c..04353f5a 100644
--- 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)