cp-tree.h (build_binary_op): Remove unneeded parameter.

	* cp-tree.h (build_binary_op): Remove unneeded parameter.
	* class.c (build_vrable_entry_ref): Adjust call to
	build_binary_op.
	* decl.c (expand_static_init): Likewise.
	(grokdeclarator): Likewise.
	(finish_function): Likewise.
	* decl2.c (delete_sanity): Likewise.
	(do_dtors): Likewise.
	(do_ctors): Likewise.
	* error.c (dump_type_suffix): Likewise.
	* expr.c (cplus_expand_expr): Likewise.
	* init.c (resolve_offset_ref): Likewise.
	(build_new): Likewise.
	(build_new_1): Likewise.
	(build_vec_delete_1): Likewise.
	(expand_vec_init_catch_clause): Likewise.
	(build_delete): Likewise.
	* pt.c (tsubst): Likewise.
	* rtti.c (synthesize_tinfo_fn): Likewise.
	* search.c (expand_upcast_fixups): Likewise.
	(expand_direct_vtbls_init): Likewise.
	* typeck.c (get_member_function_from_ptrfunc): Likewise.
	(build_binary_op_nodefault): Likewise.
	(point_int_sum): Likewise.
	(pointer_diff): Likewise.
	(build_unary_op): Likewise.
	(build_modify_expr): Likewise.
	(get_delta_difference): Likewise.
	(build_ptrmemfunc): Likewise.
	(expand_ptrmemfunc_cst): Likewise.

From-SVN: r26566

12 files changed, 89 insertions, 66 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 6166802..4740af5 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,36 @@
+1999-04-20  Mark Mitchell  <mark@codesourcery.com>
+
+	* cp-tree.h (build_binary_op): Remove unneeded parameter.
+	* class.c (build_vrable_entry_ref): Adjust call to
+	build_binary_op.
+	* decl.c (expand_static_init): Likewise.
+	(grokdeclarator): Likewise.
+	(finish_function): Likewise.
+	* decl2.c (delete_sanity): Likewise.
+	(do_dtors): Likewise.
+	(do_ctors): Likewise.
+	* error.c (dump_type_suffix): Likewise.
+	* expr.c (cplus_expand_expr): Likewise.
+	* init.c (resolve_offset_ref): Likewise.
+	(build_new): Likewise.
+	(build_new_1): Likewise.
+	(build_vec_delete_1): Likewise.
+	(expand_vec_init_catch_clause): Likewise.
+	(build_delete): Likewise.
+	* pt.c (tsubst): Likewise.
+	* rtti.c (synthesize_tinfo_fn): Likewise.
+	* search.c (expand_upcast_fixups): Likewise.
+	(expand_direct_vtbls_init): Likewise.
+	* typeck.c (get_member_function_from_ptrfunc): Likewise.
+	(build_binary_op_nodefault): Likewise.
+	(point_int_sum): Likewise.
+	(pointer_diff): Likewise.
+	(build_unary_op): Likewise.
+	(build_modify_expr): Likewise.
+	(get_delta_difference): Likewise.
+	(build_ptrmemfunc): Likewise.
+	(expand_ptrmemfunc_cst): Likewise.
+	
 1999-04-20  Jason Merrill  <jason@yorick.cygnus.com>
 
 	* decl.c (grokfndecl): Always call cplus_decl_attributes.
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index ac762b5..87a82c7 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -489,7 +489,7 @@ build_vtable_entry_ref (basetype, vtbl, idx)
   i = build_c_cast (ptrdiff_type_node, build_unary_op (ADDR_EXPR, i, 0));
   i2 = build_array_ref (vtbl, build_int_2(0,0));
   i2 = build_c_cast (ptrdiff_type_node, build_unary_op (ADDR_EXPR, i2, 0));
-  i = build_binary_op (MINUS_EXPR, i, i2, 0);
+  i = build_binary_op (MINUS_EXPR, i, i2);
   i = build_tree_list (build_string (1, "i"), i);
 
   expand_asm_operands (build_string (sizeof(asm_stmt)-1, asm_stmt),
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 21392ce..b94f6f5 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3425,7 +3425,7 @@ extern tree build_function_call			PROTO((tree, tree));
 extern tree build_function_call_maybe		PROTO((tree, tree));
 extern tree convert_arguments			PROTO((tree, tree, tree, int));
 extern tree build_x_binary_op			PROTO((enum tree_code, tree, tree));
-extern tree build_binary_op			PROTO((enum tree_code, tree, tree, int));
+extern tree build_binary_op			PROTO((enum tree_code, tree, tree));
 extern tree build_binary_op_nodefault		PROTO((enum tree_code, tree, tree, enum tree_code));
 extern tree build_component_addr		PROTO((tree, tree, const char *));
 extern tree build_x_unary_op			PROTO((enum tree_code, tree));
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index d611236..331d627 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -8303,7 +8303,7 @@ expand_static_init (decl, init)
 
       /* Begin the conditional initialization.  */
       expand_start_cond (build_binary_op (EQ_EXPR, temp,
-					  integer_zero_node, 1), 0);
+					  integer_zero_node), 0);
       expand_start_target_temps ();
 
       /* Do the initialization itself.  */
@@ -10225,7 +10225,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		  = fold (build_binary_op (MINUS_EXPR,
 					   cp_convert (index_type, size),
 					   cp_convert (index_type,
-						       integer_one_node), 1));
+						       integer_one_node)));
 		if (! TREE_CONSTANT (itype))
 		  itype = variable_size (itype);
 		else if (TREE_OVERFLOW (itype))
@@ -13973,7 +13973,7 @@ finish_function (lineno, flags, nested)
 	  if (! ok_to_optimize_dtor)
 	    {
 	      cond = build_binary_op (NE_EXPR,
-				      current_class_ptr, integer_zero_node, 1);
+				      current_class_ptr, integer_zero_node);
 	      expand_start_cond (cond, 0);
 	    }
 
@@ -14033,7 +14033,7 @@ finish_function (lineno, flags, nested)
 	  if (flag_this_is_variable > 0)
 	    {
 	      cond = build_binary_op (EQ_EXPR,
-				      current_class_ptr, integer_zero_node, 1);
+				      current_class_ptr, integer_zero_node);
 	      thenclause = build_modify_expr (current_class_ptr, NOP_EXPR,
 					      build_new (NULL_TREE, current_class_type, void_type_node, 0));
 	    }
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 70c9727..ac52f6d 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1176,7 +1176,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
 
   if (doing_vec == 2)
     {
-      maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
+      maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node);
       pedwarn ("anachronistic use of array size in vector delete");
     }
 
@@ -3176,7 +3176,7 @@ do_dtors (start)
 	    {
 	      tree sentry = get_sentry (DECL_ASSEMBLER_NAME (decl));
 	      sentry = build_unary_op (PREDECREMENT_EXPR, sentry, 0);
-	      sentry = build_binary_op (EQ_EXPR, sentry, integer_zero_node, 1);
+	      sentry = build_binary_op (EQ_EXPR, sentry, integer_zero_node);
 	      expand_start_cond (sentry, 0);
 	    }
 
@@ -3255,7 +3255,7 @@ do_ctors (start)
 	      tree sentry = get_sentry (DECL_ASSEMBLER_NAME (decl));
 	      sentry = build_unary_op (PREINCREMENT_EXPR, sentry, 0);
 	      sentry = build_binary_op
-		(EQ_EXPR, sentry, integer_one_node, 1);
+		(EQ_EXPR, sentry, integer_one_node);
 	      expand_start_cond (sentry, 0);
 	    }
 
diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 025e932..b59b619 100644
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -579,7 +579,7 @@ dump_type_suffix (t, v, canonical_name)
 	  else
 	    dump_expr (fold (build_binary_op
 			     (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
-			      integer_one_node, 1)), 0);
+			      integer_one_node)), 0);
 	}
       OB_PUTC (']');
       dump_type_suffix (TREE_TYPE (t), v, canonical_name);
diff --git a/gcc/cp/expr.c b/gcc/cp/expr.c
index 22dd075..bc745ff 100644
--- a/gcc/cp/expr.c
+++ b/gcc/cp/expr.c
@@ -219,7 +219,7 @@ cplus_expand_expr (exp, target, tmode, modifier)
 	(expand_vec_init
 	 (NULL_TREE, TREE_OPERAND (exp, 0),
 	  build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2),
-			   integer_one_node, 1),
+			   integer_one_node),
 	  TREE_OPERAND (exp, 1), 0), target, tmode, modifier);
 
     case NEW_EXPR:
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index d8e5458..b825bfb 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -1793,8 +1793,7 @@ resolve_offset_ref (exp)
 	 pointer with a real value of 0 is distinguishable from an
 	 offset of the first member of a structure.  */
       member = build_binary_op (MINUS_EXPR, member,
-				cp_convert (ptrdiff_type_node, integer_one_node),
-				0);
+				cp_convert (ptrdiff_type_node, integer_one_node));
 
       return build1 (INDIRECT_REF, type,
 		     build (PLUS_EXPR, build_pointer_type (type),
@@ -1945,7 +1944,7 @@ build_new (placement, decl, init, use_global_new)
 		      nelts = integer_zero_node;
 		    }
 		  else
-		    nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
+		    nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
 		}
 	    }
 	  else
@@ -2134,7 +2133,7 @@ build_new_1 (exp)
   while (TREE_CODE (true_type) == ARRAY_TYPE)
     {
       tree this_nelts = array_type_nelts_top (true_type);
-      nelts = build_binary_op (MULT_EXPR, nelts, this_nelts, 1);
+      nelts = build_binary_op (MULT_EXPR, nelts, this_nelts);
       true_type = TREE_TYPE (true_type);
     }
 
@@ -2143,7 +2142,7 @@ build_new_1 (exp)
 
   if (has_array)
     size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
-				  nelts, 1));
+				  nelts));
   else
     size = size_in_bytes (type);
 
@@ -2285,7 +2284,7 @@ build_new_1 (exp)
       tree extra = BI_header_size;
       tree cookie, exp1;
       rval = convert (string_type_node, rval); /* for ptr arithmetic */
-      rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra, 1));
+      rval = save_expr (build_binary_op (PLUS_EXPR, rval, extra));
       /* Store header info.  */
       cookie = build_indirect_ref (build (MINUS_EXPR,
 					  build_pointer_type (BI_header_type),
@@ -2471,7 +2470,7 @@ build_new_1 (exp)
     {
       /* Did we modify the storage?  */
       tree ifexp = build_binary_op (NE_EXPR, alloc_node,
-				    integer_zero_node, 1);
+				    integer_zero_node);
       rval = build_conditional_expr (ifexp, rval, alloc_node);
     }
 
@@ -2541,8 +2540,7 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
       tree base_tbd = cp_convert (ptype,
 				  build_binary_op (MINUS_EXPR,
 						   cp_convert (ptr_type_node, base),
-						   BI_header_size,
-						   1));
+						   BI_header_size));
       /* This is the real size */
       virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
       body = build_expr_list (NULL_TREE,
@@ -2597,8 +2595,7 @@ build_vec_delete_1 (base, maxindex, type, auto_delete_vec, auto_delete,
 	  base_tbd = cp_convert (ptype,
 				 build_binary_op (MINUS_EXPR,
 						  cp_convert (string_type_node, base),
-						  BI_header_size,
-						  1));
+						  BI_header_size));
 	  /* True size with header.  */
 	  virtual_size = size_binop (PLUS_EXPR, virtual_size, BI_header_size);
 	}
@@ -2697,7 +2694,7 @@ expand_vec_init_catch_clause (rval, type, maxindex, iterator)
     
   e = build_vec_delete_1 (rval,
 			  build_binary_op (MINUS_EXPR, maxindex, 
-					   iterator, 1),
+					   iterator),
 			  type,
 			  /*auto_delete_vec=*/integer_zero_node,
 			  /*auto_delete=*/integer_zero_node,
@@ -3091,7 +3088,7 @@ build_delete (type, addr, auto_delete, flags, use_global_delete)
 	ifexp = integer_one_node;
       else
 	/* Handle deleting a null pointer.  */
-	ifexp = fold (build_binary_op (NE_EXPR, addr, integer_zero_node, 1));
+	ifexp = fold (build_binary_op (NE_EXPR, addr, integer_zero_node));
 
       if (ifexp != integer_one_node)
 	expr = build (COND_EXPR, void_type_node,
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index f2e40b3..5a36247 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -6136,7 +6136,7 @@ tsubst (t, args, complain, in_decl)
 	    return error_mark_node;
 	  }
 
-	max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node, 1));
+	max = fold (build_binary_op (MINUS_EXPR, max, integer_one_node));
 	if (!TREE_PERMANENT (max) && !allocation_temporary_p ())
 	  max = copy_to_permanent (max);
 	return build_index_type (max);
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index 6ff3c60..15efd61 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -1129,7 +1129,7 @@ synthesize_tinfo_fn (fndecl)
   addr = decay_conversion (tdecl);
   tmp = cp_convert (build_pointer_type (ptr_type_node), addr);
   tmp = build_indirect_ref (tmp, 0);
-  tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node, 1);
+  tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node);
   expand_start_cond (tmp, 0);
 
   if (TREE_CODE (type) == FUNCTION_TYPE)
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 74b9c2d..0551474 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -2527,7 +2527,7 @@ expand_upcast_fixups (binfo, addr, orig_addr, vbase, vbase_addr, t,
 	  /* This is a upcast, so we have to add the offset for the
 	     virtual base.  */
 	  old_delta = build_binary_op (PLUS_EXPR, old_delta,
-				       TREE_VALUE (delta), 0);
+				       TREE_VALUE (delta));
 	  if (vc)
 	    {
 	      /* If this is set, we need to subtract out the delta
@@ -2548,7 +2548,7 @@ expand_upcast_fixups (binfo, addr, orig_addr, vbase, vbase_addr, t,
    
 	      /* This is a downcast, so we have to subtract the offset
 		 for the virtual base.  */
-	      old_delta = build_binary_op (MINUS_EXPR, old_delta, vc_delta, 0);
+	      old_delta = build_binary_op (MINUS_EXPR, old_delta, vc_delta);
 	    }
 
 	  TREE_READONLY (new_delta) = 0;
@@ -2690,7 +2690,7 @@ expand_indirect_vtbls_init (binfo, true_exp, decl_ptr)
 	      warning ("recoverable internal compiler error, nobody's in charge!");
 	      in_charge_node = integer_zero_node;
 	    }
-	  in_charge_node = build_binary_op (EQ_EXPR, in_charge_node, integer_zero_node, 1);
+	  in_charge_node = build_binary_op (EQ_EXPR, in_charge_node, integer_zero_node);
 	  expand_start_cond (in_charge_node, 0);
 	  emit_insns (fixup_insns);
 	  expand_end_cond ();
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index fd21ed0..c74692c 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2871,7 +2871,7 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
 			   (build_component_ref (function,
 						 index_identifier,
 						 NULL_TREE, 0)));
-	  e1 = build_binary_op (GT_EXPR, idx, integer_zero_node, 1);
+	  e1 = build_binary_op (GT_EXPR, idx, integer_zero_node);
 
 	  /* Convert down to the right base, before using the instance.  */
 	  instance = convert_pointer_to_real (basetype, instance_ptr);
@@ -2887,7 +2887,7 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
 	  vtbl = build_indirect_ref (vtbl, NULL_PTR);
 	  aref = build_array_ref (vtbl, build_binary_op (MINUS_EXPR,
 							 idx,
-							 integer_one_node, 1));
+							 integer_one_node));
 	  if (! flag_vtable_thunks)
 	    {
 	      aref = save_expr (aref);
@@ -2899,7 +2899,7 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
 							      delta_identifier,
 							      NULL_TREE, 0),
 					 integer_zero_node),
-		 delta, 1);
+		 delta);
 	    }
 
 	  if (flag_vtable_thunks)
@@ -3262,10 +3262,9 @@ build_x_binary_op (code, arg1, arg2)
 }
 
 tree
-build_binary_op (code, arg1, arg2, convert_p)
+build_binary_op (code, arg1, arg2)
      enum tree_code code;
      tree arg1, arg2;
-     int convert_p ATTRIBUTE_UNUSED;
 {
   return build_binary_op_nodefault (code, arg1, arg2, code);
 }
@@ -3661,18 +3660,17 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	  tree e1, e2, e3;
 	  tree integer_neg_one_node
 	    = build_binary_op (MINUS_EXPR, integer_zero_node,
-			       integer_one_node, 1);
-	  e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
-	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
+			       integer_one_node);
+	  e1 = build_binary_op (EQ_EXPR, index0, index1);
+	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node);
 	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
-				build_binary_op (EQ_EXPR, delta20, delta21, 1),
-				1);
-	  e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1);
-	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
-	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
+				build_binary_op (EQ_EXPR, delta20, delta21));
+	  e3 = build_binary_op (EQ_EXPR, pfn0, pfn1);
+	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3);
+	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2);
 	  if (code == EQ_EXPR)
 	    return e2;
-	  return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
+	  return build_binary_op (EQ_EXPR, e2, integer_zero_node);
 	}
       else if (TYPE_PTRMEMFUNC_P (type0)
 	       && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1)
@@ -3685,7 +3683,7 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	  tree delta21 = integer_zero_node;
 	  tree e1, e2, e3;
 	  tree integer_neg_one_node
-	    = build_binary_op (MINUS_EXPR, integer_zero_node, integer_one_node, 1);
+	    = build_binary_op (MINUS_EXPR, integer_zero_node, integer_one_node);
 	  if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL
 	      && DECL_VINDEX (TREE_OPERAND (op1, 0)))
 	    {
@@ -3710,23 +3708,20 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	    TREE_CONSTANT (nop1) = TREE_CONSTANT (op1);
 	    op1 = nop1;
 	  }
-	  e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
-	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
+	  e1 = build_binary_op (EQ_EXPR, index0, index1);
+	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node);
 	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
-				build_binary_op (EQ_EXPR, delta20, delta21, 1),
-				1);
-	  e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1);
-	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
-	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
+				build_binary_op (EQ_EXPR, delta20, delta21));
+	  e3 = build_binary_op (EQ_EXPR, pfn0, op1);
+	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3);
+	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2);
 	  if (code == EQ_EXPR)
 	    return e2;
-	  return build_binary_op (EQ_EXPR, e2, integer_zero_node, 1);
+	  return build_binary_op (EQ_EXPR, e2, integer_zero_node);
 	}
       else if (TYPE_PTRMEMFUNC_P (type1)
 	       && TYPE_PTRMEMFUNC_FN_TYPE (type1) == type0)
-	{
-	  return build_binary_op (code, op1, op0, 1);
-	}
+	return build_binary_op (code, op1, op0);
       break;
 
     case MAX_EXPR:
@@ -4165,7 +4160,7 @@ pointer_int_sum (resultcode, ptrop, intop)
       enum tree_code subcode = resultcode;
       if (TREE_CODE (intop) == MINUS_EXPR)
 	subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
-      ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1), 1);
+      ptrop = build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1));
       intop = TREE_OPERAND (intop, 0);
     }
 
@@ -4182,8 +4177,7 @@ pointer_int_sum (resultcode, ptrop, intop)
   intop = cp_convert (result_type,
 		      build_binary_op (MULT_EXPR, intop,
 				       cp_convert (TREE_TYPE (intop),
-						   size_exp),
-				       1));
+						   size_exp)));
 
   /* Create the sum or difference.  */
 
@@ -4226,7 +4220,7 @@ pointer_diff (op0, op1, ptrtype)
      then drop through to build the divide operator.  */
 
   op0 = build_binary_op (MINUS_EXPR, cp_convert (restype, op0),
-			 cp_convert (restype, op1), 1);
+			 cp_convert (restype, op1));
 
   /* This generates an error if op1 is a pointer to an incomplete type.  */
   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
@@ -4669,7 +4663,7 @@ build_unary_op (code, xarg, noconvert)
 	  if (mark_addressable (TREE_OPERAND (arg, 0)) == 0)
 	    return error_mark_node;
 	  return build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
-				  TREE_OPERAND (arg, 1), 1);
+				  TREE_OPERAND (arg, 1));
 	}
 
       /* Uninstantiated types are all functions.  Taking the
@@ -6025,7 +6019,7 @@ build_modify_expr (lhs, modifycode, rhs)
   else
     {
       lhs = stabilize_reference (lhs);
-      newrhs = build_binary_op (modifycode, lhs, rhs, 1);
+      newrhs = build_binary_op (modifycode, lhs, rhs);
       if (newrhs == error_mark_node)
 	{
 	  cp_error ("  in evaluation of `%Q(%#T, %#T)'", modifycode,
@@ -6387,7 +6381,7 @@ get_delta_difference (from, to, force)
       
       return build_binary_op (MINUS_EXPR,
 			      integer_zero_node,
-			      delta, 1);
+			      delta);
     }
 
   if (TREE_VIA_VIRTUAL (binfo))
@@ -6525,8 +6519,8 @@ build_ptrmemfunc (type, pfn, force)
 				TYPE_METHOD_BASETYPE (TREE_TYPE (type)),
 				force);
 
-      delta = build_binary_op (PLUS_EXPR, ndelta, n, 1);
-      delta2 = build_binary_op (PLUS_EXPR, ndelta2, n, 1);
+      delta = build_binary_op (PLUS_EXPR, ndelta, n);
+      delta2 = build_binary_op (PLUS_EXPR, ndelta2, n);
       e1 = fold (build (GT_EXPR, boolean_type_node, idx, integer_zero_node));
 	  
       e2 = build_ptrmemfunc1 (TYPE_GET_PTRMEMFUNC_TYPE (type), delta, idx,
@@ -6605,8 +6599,7 @@ expand_ptrmemfunc_cst (cst, delta, idx, pfn, delta2)
       *delta2 = size_binop (PLUS_EXPR, *delta2,
 			   build_binary_op (PLUS_EXPR,
 					    *delta, 
-					    integer_zero_node,
-					    1));
+					    integer_zero_node));
     }
 }