+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.
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),
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));
/* 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. */
= 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))
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);
}
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));
}
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");
}
{
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);
}
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);
}
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);
(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:
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),
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
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);
}
if (has_array)
size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
- nelts, 1));
+ nelts));
else
size = size_in_bytes (type);
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),
{
/* 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);
}
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,
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);
}
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,
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,
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);
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)
/* 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
/* 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;
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 ();
(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);
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);
delta_identifier,
NULL_TREE, 0),
integer_zero_node),
- delta, 1);
+ delta);
}
if (flag_vtable_thunks)
}
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);
}
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)
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)))
{
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:
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);
}
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. */
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)
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
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,
return build_binary_op (MINUS_EXPR,
integer_zero_node,
- delta, 1);
+ delta);
}
if (TREE_VIA_VIRTUAL (binfo))
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,
*delta2 = size_binop (PLUS_EXPR, *delta2,
build_binary_op (PLUS_EXPR,
*delta,
- integer_zero_node,
- 1));
+ integer_zero_node));
}
}
OSDN Git Service
