+2000-06-29 Mark Mitchell <mark@codesourcery.com>
+
+ * c-common.c: Include c-common.h, not c-lex.h or c-tree.h.
+ * c-common.h (flag_const_strings): Declare.
+ (warn_format): Likewise.
+ (flag_traditional): Likewise.
+ (flag_isoc99): Likewise.
+ (warn_parentheses): Likewise.
+ (warn_conversion): Likewise.
+ (C_TYPE_OBJECT_P): Likewise.
+ (C_TYPE_INCOMPLETE_P): Likewise.
+ (C_TYPE_FUNCTION_P): Likewise.
+ (C_TYPE_OBJECT_OR_INCOMPLETE_P): Likewise.
+ (C_EXP_ORIGINAL_CODE): Likewise.
+ (build_unary_op): Likewise.
+ (build_binary_op): Likewise.
+ (lvalue_p): Likewise.
+ (default_conversion): Likewise.
+ (common_type): Likewise.
+ * c-tree.h (C_TYPE_OBJECT_P): Remove.
+ (C_TYPE_INCOMPLETE_P): Likewise.
+ (C_TYPE_FUNCTION_P): Likewise.
+ (C_TYPE_OBJECT_OR_INCOMPLETE_P): Likewise.
+ (C_EXP_ORIGINAL_CODE): Likewise.
+ (common_type): Likewise.
+ (default_conversion): Likewise.
+ (build_binary_op): Likewise.
+ (build_unary_op): Likewise.
+ (lvalue_p): Likewise.
+ (flag_const_strings): Likewise.
+ (warn_format): Likewise.
+ (warn_conversion): Likewise.
+ (flag_traditional): Likewise.
+ (flag_isoc99): Likewise.
+ (warn_parentheses): Likewise.
+
2000-06-29 James E. Wilson <wilson@cygnus.com>
* config/ia64/linux.h (LINK_SPEC): Change so.1 to so.2.
#include "config.h"
#include "system.h"
#include "tree.h"
-#include "c-lex.h"
-#include "c-tree.h"
+#include "c-common.h"
#include "flags.h"
#include "toplev.h"
#include "output.h"
CTI_MAX
};
-extern tree c_global_trees[CTI_MAX];
-
-typedef enum c_language_kind
-{
- clk_c, /* A dialect of C: K&R C, ANSI/ISO C89, C2000,
- etc. */
- clk_cplusplus, /* ANSI/ISO C++ */
- clk_objective_c /* Objective C */
-}
-c_language_kind;
-
-/* The variant of the C language being processed. Each C language
- front-end defines this variable. */
-extern c_language_kind c_language;
-
#define wchar_type_node c_global_trees[CTI_WCHAR_TYPE]
#define signed_wchar_type_node c_global_trees[CTI_SIGNED_WCHAR_TYPE]
#define unsigned_wchar_type_node c_global_trees[CTI_UNSIGNED_WCHAR_TYPE]
#define g77_longint_type_node c_global_trees[CTI_G77_LONGINT_TYPE]
#define g77_ulongint_type_node c_global_trees[CTI_G77_ULONGINT_TYPE]
+extern tree c_global_trees[CTI_MAX];
+
+typedef enum c_language_kind
+{
+ clk_c, /* A dialect of C: K&R C, ANSI/ISO C89, C2000,
+ etc. */
+ clk_cplusplus, /* ANSI/ISO C++ */
+ clk_objective_c /* Objective C */
+}
+c_language_kind;
+
+/* The variant of the C language being processed. Each C language
+ front-end defines this variable. */
+
+extern c_language_kind c_language;
+
+/* Nonzero means give string constants the type `const char *', rather
+ than `char *'. */
+
+extern int flag_const_strings;
+
+/* Warn about *printf or *scanf format/argument anomalies. */
+
+extern int warn_format;
+
+/* Nonzero means do some things the same way PCC does. */
+
+extern int flag_traditional;
+
+/* Nonzero means use the ISO C99 dialect of C. */
+
+extern int flag_isoc99;
+
+/* Nonzero means warn about suggesting putting in ()'s. */
+
+extern int warn_parentheses;
+
+/* Warn if a type conversion is done that might have confusing results. */
+
+extern int warn_conversion;
+
+/* C types are partitioned into three subsets: object, function, and
+ incomplete types. */
+#define C_TYPE_OBJECT_P(type) \
+ (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
+
+#define C_TYPE_INCOMPLETE_P(type) \
+ (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
+
+#define C_TYPE_FUNCTION_P(type) \
+ (TREE_CODE (type) == FUNCTION_TYPE)
+
+/* For convenience we define a single macro to identify the class of
+ object or incomplete types. */
+#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
+ (!C_TYPE_FUNCTION_P (type))
+
+/* Record in each node resulting from a binary operator
+ what operator was specified for it. */
+#define C_EXP_ORIGINAL_CODE(exp) ((enum tree_code) TREE_COMPLEXITY (exp))
+
/* Pointer to function to generate the VAR_DECL for __FUNCTION__ etc.
ID is the identifier to use, NAME is the string.
TYPE_DEP indicates whether it depends on type of the function or not
extern tree convert_and_check PARAMS ((tree, tree));
extern void overflow_warning PARAMS ((tree));
extern void unsigned_conversion_warning PARAMS ((tree, tree));
+
/* Read the rest of the current #-directive line. */
#if USE_CPPLIB
extern char *get_directive_line PARAMS ((void));
extern int self_promoting_args_p PARAMS ((tree));
extern tree simple_type_promotes_to PARAMS ((tree));
-
+\f
/* These macros provide convenient access to the various _STMT nodes
created when parsing template declarations. */
#undef DEFTREECODE
extern void add_c_tree_codes PARAMS ((void));
+\f
+
+/* These functions must be defined by each front-end which implements
+ a variant of the C language. They are used in c-common.c. */
+
+extern tree build_unary_op PARAMS ((enum tree_code,
+ tree, int));
+extern tree build_binary_op PARAMS ((enum tree_code,
+ tree, tree, int));
+extern int lvalue_p PARAMS ((tree));
+extern tree default_conversion PARAMS ((tree));
+
+/* Given two integer or real types, return the type for their sum.
+ Given two compatible ANSI C types, returns the merged type. */
+
+extern tree common_type PARAMS ((tree, tree));
+
nonzero if the definition of the type has already started. */
#define C_TYPE_BEING_DEFINED(type) TYPE_LANG_FLAG_0 (type)
-/* C types are partitioned into three subsets: object, function, and
- incomplete types. */
-#define C_TYPE_OBJECT_P(type) \
- (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
-
-#define C_TYPE_FUNCTION_P(type) \
- (TREE_CODE (type) == FUNCTION_TYPE)
-
-#define C_TYPE_INCOMPLETE_P(type) \
- (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
-
-/* For convenience we define a single macro to identify the class of
- object or incomplete types. */
-#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
- (!C_TYPE_FUNCTION_P (type))
-
/* In a RECORD_TYPE, a sorted array of the fields of the type. */
struct lang_type
{
#define C_TYPE_VARIABLE_SIZE(type) TYPE_LANG_FLAG_1 (type)
#define C_DECL_VARIABLE_SIZE(type) DECL_LANG_FLAG_0 (type)
-/* Record in each node resulting from a binary operator
- what operator was specified for it. */
-#define C_EXP_ORIGINAL_CODE(exp) ((enum tree_code) TREE_COMPLEXITY (exp))
-
#if 0 /* Not used. */
/* Record whether a decl for a function or function pointer has
already been mentioned (in a warning) because it was called
/* in c-typeck.c */
extern tree require_complete_type PARAMS ((tree));
extern void incomplete_type_error PARAMS ((tree, tree));
-/* Given two integer or real types, return the type for their sum.
- Given two compatible ANSI C types, returns the merged type. */
-extern tree common_type PARAMS ((tree, tree));
extern int comptypes PARAMS ((tree, tree));
extern tree c_sizeof PARAMS ((tree));
extern tree c_sizeof_nowarn PARAMS ((tree));
extern tree c_size_in_bytes PARAMS ((tree));
extern tree c_alignof PARAMS ((tree));
extern tree c_alignof_expr PARAMS ((tree));
-extern tree default_conversion PARAMS ((tree));
extern tree build_component_ref PARAMS ((tree, tree));
extern tree build_indirect_ref PARAMS ((tree, const char *));
extern tree build_array_ref PARAMS ((tree, tree));
extern tree build_function_call PARAMS ((tree, tree));
extern tree parser_build_binary_op PARAMS ((enum tree_code,
tree, tree));
-extern tree build_binary_op PARAMS ((enum tree_code,
- tree, tree, int));
-extern tree build_unary_op PARAMS ((enum tree_code,
- tree, int));
-extern int lvalue_p PARAMS ((tree));
extern int lvalue_or_else PARAMS ((tree, const char *));
extern void readonly_warning PARAMS ((tree, const char *));
extern int mark_addressable PARAMS ((tree));
extern int warn_implicit;
-/* Nonzero means give string constants the type `const char *'
- to get extra warnings from them. These warnings will be too numerous
- to be useful, except in thoroughly ANSIfied programs. */
-
-extern int flag_const_strings;
-
/* Nonzero means warn about sizeof (function) or addition/subtraction
of function pointers. */
extern int warn_traditional;
-/* Warn about *printf or *scanf format/argument anomalies. */
-
-extern int warn_format;
-
/* Warn about a subscript that has type char. */
extern int warn_char_subscripts;
-/* Warn if a type conversion is done that might have confusing results. */
-
-extern int warn_conversion;
-
/* Warn if main is suspicious. */
extern int warn_main;
-/* Nonzero means do some things the same way PCC does. */
-
-extern int flag_traditional;
-
-/* Nonzero means use the ISO C99 dialect of C. */
-
-extern int flag_isoc99;
-
/* Nonzero means to allow single precision math even if we're generally
being traditional. */
extern int flag_allow_single_precision;
-/* Nonzero means warn about suggesting putting in ()'s. */
-
-extern int warn_parentheses;
-
/* Warn if initializer is not completely bracketed. */
extern int warn_missing_braces;
+2000-06-29 Mark Mitchell <mark@codesourcery.com>
+
+ * cp-tree.h (flag_const_strings): Remove.
+ (warn_parentheses): Likewise.
+ (warn_format): Likewise.
+ (common_type): Likewise.
+ (default_conversion): Likewise.
+ (build_binary_op): Likewise.
+ (cp_build_binary_op): New macro.
+ * call.c (build_new_op): Use cp_build_binary_op instead of
+ build_binary_op.
+ * class.c (build_vtable_entry_ref): Likewise.
+ * decl.c (expand_static_init): Likewise.
+ (compute_array_index_type): Likewise.
+ (build_enumerator): Likewise.
+ * decl2.c (delete_sanity): Likewise.
+ (start_static_initialization_or_destruction): Likewise.
+ * error.c (dump_type_suffix): Likewise.
+ * init.c (resolve_offset_ref): Likewise.
+ (build_new): Likewise.
+ (build_new_1): Likewise.
+ (build_vec_delete_1): Likewise.
+ (build_vec_init): Likewise.
+ (build_delete): Likewise.
+ * rtti.c (synthesize_tinfo_fn): Likewise.
+ (synthesize_tinfo_var): Likewise.
+ * search.c (expand_upcast_fixups): Likewise.
+ (fixup_all_virtual_upcast_offsets): Likewise.
+ * typeck.c (build_array_ref): Likewise.
+ (get_member_function_from_ptrfunc): Likewise.
+ (build_binary_op): Add parameter.
+ (pointer_int_sum): Use cp_build_binary_op.
+ (pointer_diff): Likewise.
+ (build_modify_expr): Likewise.
+ (get_delta_difference): Likewise.
+ (build_ptrmemfunc): Likewise.
+
2000-06-29 Nathan Sidwell <nathan@codesourcery.com>
* cp-tree.h (SET_DECL_ARTIFICIAL): Remove.
case BIT_XOR_EXPR:
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
- return build_binary_op (code, arg1, arg2);
+ return cp_build_binary_op (code, arg1, arg2);
case CONVERT_EXPR:
case NEGATE_EXPR:
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);
+ i = cp_build_binary_op (MINUS_EXPR, i, i2);
i = build_tree_list (build_string (1, "i"), i);
finish_asm_stmt (ridpointers[RID_VOLATILE],
extern int warn_return_type;
-/* Nonzero means give string constants the type `const char *', as mandated
- by the standard. */
-
-extern int flag_const_strings;
-
/* If non-NULL, dump the tree structure for the entire translation
unit to this file. */
extern int warn_pointer_arith;
-/* Nonzero means warn about suggesting putting in ()'s. */
-
-extern int warn_parentheses;
-
/* Nonzero means warn about multiple (redundant) decls for the same single
variable or function. */
extern int warn_cast_qual;
-/* Warn about *printf or *scanf format/argument anomalies. */
-
-extern int warn_format;
-
/* Nonzero means warn about non virtual destructors in classes that have
virtual functions. */
extern int type_unknown_p PARAMS ((tree));
extern tree commonparms PARAMS ((tree, tree));
extern tree original_type PARAMS ((tree));
-extern tree common_type PARAMS ((tree, tree));
extern int comp_except_specs PARAMS ((tree, tree, int));
extern int comptypes PARAMS ((tree, tree, int));
extern int comp_target_types PARAMS ((tree, tree, int));
extern tree c_alignof PARAMS ((tree));
extern tree inline_conversion PARAMS ((tree));
extern tree decay_conversion PARAMS ((tree));
-extern tree default_conversion PARAMS ((tree));
extern tree build_object_ref PARAMS ((tree, tree, tree));
extern tree build_component_ref_1 PARAMS ((tree, tree, int));
extern tree build_component_ref PARAMS ((tree, tree, tree, int));
extern tree build_function_call_maybe PARAMS ((tree, tree));
extern tree convert_arguments PARAMS ((tree, tree, tree, int));
extern tree build_x_binary_op PARAMS ((enum tree_code, tree, tree));
-extern tree build_binary_op PARAMS ((enum tree_code, tree, tree));
extern tree build_x_unary_op PARAMS ((enum tree_code, tree));
-extern tree build_unary_op PARAMS ((enum tree_code, tree, int));
extern tree unary_complex_lvalue PARAMS ((enum tree_code, tree));
extern int mark_addressable PARAMS ((tree));
extern tree build_x_conditional_expr PARAMS ((tree, tree, tree));
extern tree composite_pointer_type PARAMS ((tree, tree, tree, tree,
const char*));
extern tree check_return_expr PARAMS ((tree));
+#define cp_build_binary_op(code, arg1, arg2) \
+ build_binary_op(code, arg1, arg2, 1)
/* in typeck2.c */
extern tree error_not_base_type PARAMS ((tree, tree));
/* Begin the conditional initialization. */
if_stmt = begin_if_stmt ();
- finish_if_stmt_cond (build_binary_op (EQ_EXPR, temp,
- integer_zero_node),
+ finish_if_stmt_cond (cp_build_binary_op (EQ_EXPR, temp,
+ integer_zero_node),
if_stmt);
then_clause = begin_compound_stmt (/*has_no_scope=*/0);
/* Compute the index of the largest element in the array. It is
one less than the number of elements in the array. */
itype
- = fold (build_binary_op (MINUS_EXPR,
- cp_convert (ssizetype, size),
- cp_convert (ssizetype,
- integer_one_node)));
+ = fold (cp_build_binary_op (MINUS_EXPR,
+ cp_convert (ssizetype, size),
+ cp_convert (ssizetype,
+ integer_one_node)));
/* Check for variable-sized arrays. We allow such things as an
extension, even though they are not allowed in ANSI/ISO C++. */
/* The next value is the previous value ... */
prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
/* ... plus one. */
- value = build_binary_op (PLUS_EXPR,
- prev_value,
- integer_one_node);
+ value = cp_build_binary_op (PLUS_EXPR,
+ prev_value,
+ integer_one_node);
if (tree_int_cst_lt (value, prev_value))
cp_error ("overflow in enumeration values at `%D'", name);
if (doing_vec == 2)
{
- maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node);
+ maxindex = cp_build_binary_op (MINUS_EXPR, size, integer_one_node);
pedwarn ("anachronistic use of array size in vector delete");
}
/* Conditionalize this initialization on being in the right priority
and being initializing/finalizing appropriately. */
sentry_if_stmt = begin_if_stmt ();
- cond = build_binary_op (EQ_EXPR,
- priority_decl,
- build_int_2 (priority, 0));
+ cond = cp_build_binary_op (EQ_EXPR,
+ priority_decl,
+ build_int_2 (priority, 0));
init_cond = initp ? integer_one_node : integer_zero_node;
- init_cond = build_binary_op (EQ_EXPR,
- initialize_p_decl,
- init_cond);
- cond = build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
+ init_cond = cp_build_binary_op (EQ_EXPR,
+ initialize_p_decl,
+ init_cond);
+ cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, init_cond);
/* We need a sentry if this is an object with external linkage that
might be initialized in more than one place. (For example, a
only if the SENTRY is one, i.e., if we are the last to
destroy the variable. */
if (initp)
- sentry_cond = build_binary_op (EQ_EXPR,
- build_unary_op (PREINCREMENT_EXPR,
- sentry,
- /*noconvert=*/1),
- integer_one_node);
+ sentry_cond
+ = cp_build_binary_op (EQ_EXPR,
+ build_unary_op (PREINCREMENT_EXPR,
+ sentry,
+ /*noconvert=*/1),
+ integer_one_node);
else
- sentry_cond = build_binary_op (EQ_EXPR,
- build_unary_op (PREDECREMENT_EXPR,
- sentry,
- /*noconvert=*/1),
- integer_zero_node);
-
- cond = build_binary_op (TRUTH_ANDIF_EXPR, cond, sentry_cond);
+ sentry_cond
+ = cp_build_binary_op (EQ_EXPR,
+ build_unary_op (PREDECREMENT_EXPR,
+ sentry,
+ /*noconvert=*/1),
+ integer_zero_node);
+
+ cond = cp_build_binary_op (TRUTH_ANDIF_EXPR, cond, sentry_cond);
}
finish_if_stmt_cond (cond, sentry_if_stmt);
dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0),
flags & ~TS_EXPR_PARENS);
else
- dump_expr (fold (build_binary_op
+ dump_expr (fold (cp_build_binary_op
(PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
integer_one_node)),
flags & ~TS_EXPR_PARENS);
/* Pointer to data members are offset by one, so that a null
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));
+ member = cp_build_binary_op (MINUS_EXPR, member,
+ 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);
+ nelts = cp_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);
+ nelts = cp_build_binary_op (MULT_EXPR, nelts, this_nelts);
true_type = TREE_TYPE (true_type);
}
return error_mark_node;
if (has_array)
- size = fold (build_binary_op (MULT_EXPR, size_in_bytes (true_type),
- nelts));
+ size = fold (cp_build_binary_op (MULT_EXPR, size_in_bytes (true_type),
+ nelts));
else
size = size_in_bytes (type);
{
tree cookie, exp1;
rval = convert (string_type_node, rval); /* for ptr arithmetic */
- rval = save_expr (build_binary_op (PLUS_EXPR, rval, cookie_size));
+ rval = save_expr (cp_build_binary_op (PLUS_EXPR, rval, cookie_size));
/* Store the number of bytes allocated so that we can know how
many elements to destroy later. */
if (flag_new_abi)
rval = (build_vec_init
(NULL_TREE,
save_expr (rval),
- build_binary_op (MINUS_EXPR, nelts, integer_one_node),
+ cp_build_binary_op (MINUS_EXPR, nelts, integer_one_node),
init,
/*from_array=*/0));
if (check_new && alloc_expr)
{
/* Did we modify the storage? */
- tree ifexp = build_binary_op (NE_EXPR, alloc_node,
- integer_zero_node);
+ tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node,
+ integer_zero_node);
rval = build_conditional_expr (ifexp, rval, alloc_node);
}
cookie_size = get_cookie_size (type);
base_tbd
= cp_convert (ptype,
- build_binary_op (MINUS_EXPR,
- cp_convert (string_type_node, base),
- cookie_size));
+ cp_build_binary_op (MINUS_EXPR,
+ cp_convert (string_type_node,
+ base),
+ cookie_size));
/* True size with header. */
virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size);
}
finish_compound_stmt (/*has_no_scope=*/1, try_body);
finish_cleanup_try_block (try_block);
e = build_vec_delete_1 (rval,
- build_binary_op (MINUS_EXPR, maxindex,
- iterator),
+ cp_build_binary_op (MINUS_EXPR, maxindex,
+ iterator),
type,
sfk_base_destructor,
/*use_global_delete=*/0);
ifexp = integer_one_node;
else
/* Handle deleting a null pointer. */
- ifexp = fold (build_binary_op (NE_EXPR, addr, integer_zero_node));
+ ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node));
if (ifexp != integer_one_node)
expr = build (COND_EXPR, void_type_node,
if_stmt = begin_if_stmt ();
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);
+ tmp = cp_build_binary_op (EQ_EXPR, tmp, integer_zero_node);
finish_if_stmt_cond (tmp, if_stmt);
then_clause = begin_compound_stmt (/*has_no_scope=*/0);
is_simple = 0;
/* combine offset and flags into one field */
- offset = build_binary_op (LSHIFT_EXPR, offset,
- build_int_2 (8, 0));
- offset = build_binary_op (BIT_IOR_EXPR, offset,
- build_int_2 (flags, 0));
+ offset = cp_build_binary_op (LSHIFT_EXPR, offset,
+ build_int_2 (8, 0));
+ offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
+ build_int_2 (flags, 0));
base_init = tree_cons (NULL_TREE, offset, base_init);
base_init = tree_cons (NULL_TREE, tinfo, base_init);
base_init = build (CONSTRUCTOR, NULL_TREE, NULL_TREE, base_init);
/* 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));
+ old_delta = cp_build_binary_op (PLUS_EXPR, old_delta,
+ 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);
+ old_delta = cp_build_binary_op (MINUS_EXPR, old_delta, vc_delta);
}
TREE_READONLY (new_delta) = 0;
if (!in_charge_node)
/* There's no need for any fixups in this case. */
return;
- in_charge_node = build_binary_op (EQ_EXPR,
- in_charge_node, integer_zero_node);
+ in_charge_node = cp_build_binary_op (EQ_EXPR,
+ in_charge_node, integer_zero_node);
if_stmt = begin_if_stmt ();
finish_if_stmt_cond (in_charge_node, if_stmt);
return error_mark_node;
}
- return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, ind),
+ return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind),
"array indexing");
}
}
easier to make this change. */
if (flag_new_abi)
{
- idx = build_binary_op (TRUNC_DIV_EXPR,
- build1 (NOP_EXPR, vtable_index_type, e3),
- TYPE_SIZE_UNIT (vtable_entry_type));
- e1 = build_binary_op (BIT_AND_EXPR,
- build1 (NOP_EXPR, vtable_index_type, e3),
- integer_one_node);
+ idx = cp_build_binary_op (TRUNC_DIV_EXPR,
+ build1 (NOP_EXPR, vtable_index_type, e3),
+ TYPE_SIZE_UNIT (vtable_entry_type));
+ e1 = cp_build_binary_op (BIT_AND_EXPR,
+ build1 (NOP_EXPR, vtable_index_type, e3),
+ integer_one_node);
}
else
{
(build_component_ref (function,
index_identifier,
NULL_TREE, 0)));
- e1 = build_binary_op (GE_EXPR, idx, integer_zero_node);
- idx = build_binary_op (MINUS_EXPR, idx, integer_one_node);
+ e1 = cp_build_binary_op (GE_EXPR, idx, integer_zero_node);
+ idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node);
}
vtbl = convert_pointer_to (ptr_type_node, instance);
{
aref = save_expr (aref);
- delta = build_binary_op
+ delta = cp_build_binary_op
(PLUS_EXPR,
build_conditional_expr (e1,
build_component_ref (aref,
multiple inheritance, and deal with pointer to member functions. */
tree
-build_binary_op (code, orig_op0, orig_op1)
+build_binary_op (code, orig_op0, orig_op1, convert_p)
enum tree_code code;
tree orig_op0, orig_op1;
+ int convert_p ATTRIBUTE_UNUSED;
{
tree op0, op1;
register enum tree_code code0, code1;
result_type = TREE_TYPE (op0);
}
else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0))
- return build_binary_op (code, op1, op0);
+ return cp_build_binary_op (code, op1, op0);
else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)
&& same_type_p (type0, type1))
{
NULL_TREE, 0);
delta1 = build_component_ref (op1, delta_identifier,
NULL_TREE, 0);
- e1 = build_binary_op (EQ_EXPR, delta0, delta1);
- e2 = build_binary_op (NE_EXPR,
- pfn0,
- cp_convert (TREE_TYPE (pfn0),
- integer_zero_node));
- e1 = build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
+ e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1);
+ e2 = cp_build_binary_op (NE_EXPR,
+ pfn0,
+ cp_convert (TREE_TYPE (pfn0),
+ integer_zero_node));
+ e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2);
e2 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
- e = build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
+ e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1);
}
else
{
tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1);
tree e3;
tree integer_neg_one_node
- = build_binary_op (MINUS_EXPR, integer_zero_node,
- 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));
- /* We can't use build_binary_op for this cmp because it would get
- confused by the ptr to method types and think we want pmfs. */
+ = cp_build_binary_op (MINUS_EXPR, integer_zero_node,
+ integer_one_node);
+ e1 = cp_build_binary_op (EQ_EXPR, index0, index1);
+ e2 = cp_build_binary_op (NE_EXPR, index1, integer_neg_one_node);
+ e2 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2,
+ cp_build_binary_op (EQ_EXPR,
+ delta20, delta21));
+ /* We can't use build_binary_op for this cmp because it
+ would get confused by the ptr to method types and
+ think we want pmfs. */
e3 = build (EQ_EXPR, boolean_type_node, pfn0, pfn1);
- e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3);
- e = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2);
+ e2 = cp_build_binary_op (TRUTH_ORIF_EXPR, e2, e3);
+ e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e2);
}
if (code == EQ_EXPR)
return e;
- return build_binary_op (EQ_EXPR, e, integer_zero_node);
+ return cp_build_binary_op (EQ_EXPR, e, integer_zero_node);
}
else if ((TYPE_PTRMEMFUNC_P (type0)
&& same_type_p (TYPE_PTRMEMFUNC_FN_TYPE (type0), type1))
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));
+ ptrop = cp_build_binary_op (subcode, ptrop, TREE_OPERAND (intop, 1));
intop = TREE_OPERAND (intop, 0);
}
pointer type (actually unsigned integral). */
intop = cp_convert (result_type,
- build_binary_op (MULT_EXPR, intop,
- cp_convert (TREE_TYPE (intop),
- size_exp)));
+ cp_build_binary_op (MULT_EXPR, intop,
+ cp_convert (TREE_TYPE (intop),
+ size_exp)));
/* Create the sum or difference. */
/* First do the subtraction as integers;
then drop through to build the divide operator. */
- op0 = build_binary_op (MINUS_EXPR, cp_convert (restype, op0),
- cp_convert (restype, op1));
+ op0 = cp_build_binary_op (MINUS_EXPR,
+ cp_convert (restype, op0),
+ cp_convert (restype, op1));
/* This generates an error if op1 is a pointer to an incomplete type. */
if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1))))
{
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));
+ return cp_build_binary_op (PLUS_EXPR, TREE_OPERAND (arg, 0),
+ TREE_OPERAND (arg, 1));
}
/* Uninstantiated types are all functions. Taking the
else
{
lhs = stabilize_reference (lhs);
- newrhs = build_binary_op (modifycode, lhs, rhs);
+ newrhs = cp_build_binary_op (modifycode, lhs, rhs);
if (newrhs == error_mark_node)
{
cp_error (" in evaluation of `%Q(%#T, %#T)'", modifycode,
delta = BINFO_OFFSET (binfo);
delta = cp_convert (ptrdiff_type_node, delta);
- return build_binary_op (MINUS_EXPR,
- integer_zero_node,
- delta);
+ return cp_build_binary_op (MINUS_EXPR,
+ integer_zero_node,
+ delta);
}
if (binfo_from_vbase (binfo))
n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
force);
- delta = build_binary_op (PLUS_EXPR, delta, n);
+ delta = cp_build_binary_op (PLUS_EXPR, delta, n);
return build_ptrmemfunc1 (to_type, delta, NULL_TREE, npfn,
NULL_TREE);
}
n = get_delta_difference (TYPE_PTRMEMFUNC_OBJECT_TYPE (pfn_type),
TYPE_PTRMEMFUNC_OBJECT_TYPE (to_type),
force);
- delta = build_binary_op (PLUS_EXPR, ndelta, n);
- delta2 = build_binary_op (PLUS_EXPR, ndelta2, n);
+ delta = cp_build_binary_op (PLUS_EXPR, ndelta, n);
+ delta2 = cp_build_binary_op (PLUS_EXPR, ndelta2, n);
e1 = fold (build (GT_EXPR, boolean_type_node, idx, integer_zero_node));
/* If it's a virtual function, this is what we want. */
OSDN Git Service
