From b7837065e4ec51e8a0ed5fdb0303f2273d3a5d92 Mon Sep 17 00:00:00 2001 From: steven Date: Thu, 24 Mar 2005 07:20:42 +0000 Subject: [PATCH] * typeck.c (comptypes): First determine if the types are compatible from a target-independent point of view. Check target attributes last. * class.c (build_base_path): (build_vbase_offset_vtbl_entries): (add_vcall_offset): Replace fold (buildN (...)) with fold_buildN. * error.c (dump_expr): Likewise. * init.c (build_zero_init, expand_cleanup_for_base, build_vec_delete_1): Likewise. * mangle.c (write_integer_cst): Likewise. * method.c (thunk_adjust): Likewise. * pt.c (convert_nontype_argument, tsubst, unify): Likewise. * tree.c (cxx_print_statistics, array_type_nelts_total): Likewise. * typeck.c (build_ptrmemfunc_access_expr, (get_member_function_from_ptrfunc): Likewise. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@96985 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/cp/ChangeLog | 21 ++++++++++++++- gcc/cp/class.c | 20 +++++++-------- gcc/cp/error.c | 6 ++--- gcc/cp/init.c | 26 +++++++++---------- gcc/cp/mangle.c | 8 +++--- gcc/cp/method.c | 10 ++++---- gcc/cp/pt.c | 14 +++++----- gcc/cp/tree.c | 8 +++--- gcc/cp/typeck.c | 78 ++++++++++++++++++++++++++++++++++---------------------- 9 files changed, 113 insertions(+), 78 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 2b3a99b1cf0..ae435c1a5cf 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,22 @@ +2005-03-24 Steven Bosscher + + * typeck.c (comptypes): First determine if the types are compatible + from a target-independent point of view. Check target attributes + last. + + * class.c (build_base_path): + (build_vbase_offset_vtbl_entries): + (add_vcall_offset): Replace fold (buildN (...)) with fold_buildN. + * error.c (dump_expr): Likewise. + * init.c (build_zero_init, expand_cleanup_for_base, + build_vec_delete_1): Likewise. + * mangle.c (write_integer_cst): Likewise. + * method.c (thunk_adjust): Likewise. + * pt.c (convert_nontype_argument, tsubst, unify): Likewise. + * tree.c (cxx_print_statistics, array_type_nelts_total): Likewise. + * typeck.c (build_ptrmemfunc_access_expr, + (get_member_function_from_ptrfunc): Likewise. + 2005-03-23 Joseph S. Myers * cp-objcp-common.h (LANG_HOOKS_TRUTHVALUE_CONVERSION): Remove. @@ -290,7 +309,7 @@ Add qualifiers when declaring a typedef of a function type. Member function pointers pick up the qualifiers of the typedef used to declare them. - Don't complain about creating cv-qualified function types. + Don't complain about creating cv-qualified function types. Complain about qualified function typedefs that are used to declare non-static member functions or free functions. Use cp_apply_type_quals_to_decl. diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 89346d6cf4a..c684e81aedf 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -296,8 +296,8 @@ build_base_path (enum tree_code code, if (null_test) { tree zero = cp_convert (TREE_TYPE (expr), integer_zero_node); - null_test = fold (build2 (NE_EXPR, boolean_type_node, - expr, zero)); + null_test = fold_build2 (NE_EXPR, boolean_type_node, + expr, zero); } /* If this is a simple base reference, express it as a COMPONENT_REF. */ @@ -388,9 +388,9 @@ build_base_path (enum tree_code code, out: if (null_test) - expr = fold (build3 (COND_EXPR, target_type, null_test, expr, - fold (build1 (NOP_EXPR, target_type, - integer_zero_node)))); + expr = fold_build3 (COND_EXPR, target_type, null_test, expr, + fold_build1 (NOP_EXPR, target_type, + integer_zero_node)); return expr; } @@ -7406,9 +7406,9 @@ build_vbase_offset_vtbl_entries (tree binfo, vtbl_init_data* vid) *vid->last_init = build_tree_list (NULL_TREE, - fold (build1 (NOP_EXPR, - vtable_entry_type, - delta))); + fold_build1 (NOP_EXPR, + vtable_entry_type, + delta)); vid->last_init = &TREE_CHAIN (*vid->last_init); } } @@ -7633,8 +7633,8 @@ add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid) BINFO_OFFSET from vid->binfo. */ vcall_offset = size_diffop (BINFO_OFFSET (base), BINFO_OFFSET (vid->binfo)); - vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type, - vcall_offset)); + vcall_offset = fold_build1 (NOP_EXPR, vtable_entry_type, + vcall_offset); } /* Add the initializer to the vtable. */ *vid->last_init = build_tree_list (NULL_TREE, vcall_offset); diff --git a/gcc/cp/error.c b/gcc/cp/error.c index c53e0328cd0..1748fe0aa69 100644 --- a/gcc/cp/error.c +++ b/gcc/cp/error.c @@ -1413,9 +1413,9 @@ dump_expr (tree t, int flags) if (TREE_CODE (type) == ARRAY_REF) type = build_cplus_array_type (TREE_OPERAND (type, 0), - build_index_type (fold (build2 (MINUS_EXPR, integer_type_node, - TREE_OPERAND (type, 1), - integer_one_node)))); + build_index_type (fold_build2 (MINUS_EXPR, integer_type_node, + TREE_OPERAND (type, 1), + integer_one_node))); dump_type (type, flags); if (init) { diff --git a/gcc/cp/init.c b/gcc/cp/init.c index ddf39bfd690..69089fe8269 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -222,8 +222,8 @@ build_zero_init (tree type, tree nelts, bool static_storage_p) /* Iterate over the array elements, building initializations. */ inits = NULL_TREE; if (nelts) - max_index = fold (build2 (MINUS_EXPR, TREE_TYPE (nelts), - nelts, integer_one_node)); + max_index = fold_build2 (MINUS_EXPR, TREE_TYPE (nelts), + nelts, integer_one_node); else max_index = array_type_nelts (type); gcc_assert (TREE_CODE (max_index) == INTEGER_CST); @@ -826,9 +826,9 @@ expand_cleanup_for_base (tree binfo, tree flag) binfo, LOOKUP_NORMAL | LOOKUP_NONVIRTUAL); if (flag) - expr = fold (build3 (COND_EXPR, void_type_node, - c_common_truthvalue_conversion (flag), - expr, integer_zero_node)); + expr = fold_build3 (COND_EXPR, void_type_node, + c_common_truthvalue_conversion (flag), + expr, integer_zero_node); finish_eh_cleanup (expr); } @@ -2241,9 +2241,9 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, tbase = create_temporary_var (ptype); tbase_init = build_modify_expr (tbase, NOP_EXPR, - fold (build2 (PLUS_EXPR, ptype, - base, - virtual_size))); + fold_build2 (PLUS_EXPR, ptype, + base, + virtual_size)); DECL_REGISTER (tbase) = 1; controller = build3 (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE); @@ -2308,11 +2308,11 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, body = integer_zero_node; /* Outermost wrapper: If pointer is null, punt. */ - body = fold (build3 (COND_EXPR, void_type_node, - fold (build2 (NE_EXPR, boolean_type_node, base, - convert (TREE_TYPE (base), - integer_zero_node))), - body, integer_zero_node)); + body = fold_build3 (COND_EXPR, void_type_node, + fold_build2 (NE_EXPR, boolean_type_node, base, + convert (TREE_TYPE (base), + integer_zero_node)), + body, integer_zero_node); body = build1 (NOP_EXPR, void_type_node, body); if (controller) diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c index 1d49490a81d..0f358cd98e5 100644 --- a/gcc/cp/mangle.c +++ b/gcc/cp/mangle.c @@ -1249,16 +1249,16 @@ write_integer_cst (const tree cst) if (sign < 0) { write_char ('n'); - n = fold (build1 (NEGATE_EXPR, type, n)); + n = fold_build1 (NEGATE_EXPR, type, n); } do { - tree d = fold (build2 (FLOOR_DIV_EXPR, type, n, base)); - tree tmp = fold (build2 (MULT_EXPR, type, d, base)); + tree d = fold_build2 (FLOOR_DIV_EXPR, type, n, base); + tree tmp = fold_build2 (MULT_EXPR, type, d, base); unsigned c; done = integer_zerop (d); - tmp = fold (build2 (MINUS_EXPR, type, n, tmp)); + tmp = fold_build2 (MINUS_EXPR, type, n, tmp); c = hwint_to_ascii (TREE_INT_CST_LOW (tmp), 10, ptr, done ? 1 : chunk_digits); ptr -= c; diff --git a/gcc/cp/method.c b/gcc/cp/method.c index 7a99c262471..70d664283bb 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -220,8 +220,8 @@ thunk_adjust (tree ptr, bool this_adjusting, { if (this_adjusting) /* Adjust the pointer by the constant. */ - ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, - ssize_int (fixed_offset))); + ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, + ssize_int (fixed_offset)); /* If there's a virtual offset, look up that value in the vtable and adjust the pointer again. */ @@ -242,13 +242,13 @@ thunk_adjust (tree ptr, bool this_adjusting, /* Get the offset itself. */ vtable = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (vtable)), vtable); /* Adjust the `this' pointer. */ - ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable)); + ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, vtable); } if (!this_adjusting) /* Adjust the pointer by the constant. */ - ptr = fold (build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, - ssize_int (fixed_offset))); + ptr = fold_build2 (PLUS_EXPR, TREE_TYPE (ptr), ptr, + ssize_int (fixed_offset)); return ptr; } diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 77ca2b9fc04..d5514f32aa3 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -3612,7 +3612,7 @@ convert_nontype_argument (tree type, tree expr) if (!expr || expr == error_mark_node) return expr; - expr = build_nop(type, build_address (expr)); + expr = build_nop (type, build_address (expr)); } /* [temp.arg.nontype]/5, bullet 6 @@ -7342,7 +7342,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) if (e1 == error_mark_node || e2 == error_mark_node) return error_mark_node; - return fold (build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2)); + return fold_build2 (TREE_CODE (t), TREE_TYPE (t), e1, e2); } case NEGATE_EXPR: @@ -7352,7 +7352,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) if (e == error_mark_node) return error_mark_node; - return fold (build1 (TREE_CODE (t), TREE_TYPE (t), e)); + return fold_build1 (TREE_CODE (t), TREE_TYPE (t), e); } case TYPENAME_TYPE: @@ -10158,10 +10158,10 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict) not an integer constant. */ if (TREE_CODE (parm_max) == MINUS_EXPR) { - arg_max = fold (build2 (PLUS_EXPR, - integer_type_node, - arg_max, - TREE_OPERAND (parm_max, 1))); + arg_max = fold_build2 (PLUS_EXPR, + integer_type_node, + arg_max, + TREE_OPERAND (parm_max, 1)); parm_max = TREE_OPERAND (parm_max, 0); } diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 1af7191ba2a..8b0d9aa872f 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1112,9 +1112,9 @@ cxx_print_statistics (void) tree array_type_nelts_top (tree type) { - return fold (build2 (PLUS_EXPR, sizetype, - array_type_nelts (type), - integer_one_node)); + return fold_build2 (PLUS_EXPR, sizetype, + array_type_nelts (type), + integer_one_node); } /* Return, as an INTEGER_CST node, the number of elements for TYPE @@ -1129,7 +1129,7 @@ array_type_nelts_total (tree type) while (TREE_CODE (type) == ARRAY_TYPE) { tree n = array_type_nelts_top (type); - sz = fold (build2 (MULT_EXPR, sizetype, sz, n)); + sz = fold_build2 (MULT_EXPR, sizetype, sz, n); type = TREE_TYPE (type); } return sz; diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 0ddf8f25e3e..e2cb1f8bb10 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -905,8 +905,6 @@ comp_array_types (tree t1, tree t2, bool allow_redeclaration) bool comptypes (tree t1, tree t2, int strict) { - int retval; - if (t1 == t2) return true; @@ -969,9 +967,7 @@ comptypes (tree t1, tree t2, int strict) && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) return true; - if (!(*targetm.comp_type_attributes) (t1, t2)) - return false; - + /* Compare the types. Break out if they could be the same. */ switch (TREE_CODE (t1)) { case TEMPLATE_TEMPLATE_PARM: @@ -984,7 +980,7 @@ comptypes (tree t1, tree t2, int strict) DECL_TEMPLATE_PARMS (TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (t2)))) return false; if (TREE_CODE (t1) == TEMPLATE_TEMPLATE_PARM) - return true; + break; /* Don't check inheritance. */ strict = COMPARE_STRICT; /* Fall through. */ @@ -995,18 +991,17 @@ comptypes (tree t1, tree t2, int strict) && (TYPE_TI_TEMPLATE (t1) == TYPE_TI_TEMPLATE (t2) || TREE_CODE (t1) == BOUND_TEMPLATE_TEMPLATE_PARM) && comp_template_args (TYPE_TI_ARGS (t1), TYPE_TI_ARGS (t2))) - return true; + break; if ((strict & COMPARE_BASE) && DERIVED_FROM_P (t1, t2)) - return true; + break; else if ((strict & COMPARE_DERIVED) && DERIVED_FROM_P (t2, t1)) - return true; + break; - /* We may be dealing with Objective-C instances... */ + /* We may be dealing with Objective-C instances. */ if (TREE_CODE (t1) == RECORD_TYPE - && ((retval = objc_comptypes (t1, t2, 0)) >= 0)) - return retval; - /* ...but fall through if we are not. */ + && objc_comptypes (t1, t2, 0) > 0) + break; return false; @@ -1014,51 +1009,72 @@ comptypes (tree t1, tree t2, int strict) if (!comptypes (TYPE_OFFSET_BASETYPE (t1), TYPE_OFFSET_BASETYPE (t2), strict & ~COMPARE_REDECLARATION)) return false; - return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)); + if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) + return false; + break; case POINTER_TYPE: case REFERENCE_TYPE: - return TYPE_MODE (t1) == TYPE_MODE (t2) - && TYPE_REF_CAN_ALIAS_ALL (t1) == TYPE_REF_CAN_ALIAS_ALL (t2) - && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)); + if (TYPE_MODE (t1) != TYPE_MODE (t2) + || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2) + || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) + return false; + break; case METHOD_TYPE: case FUNCTION_TYPE: if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) return false; - return compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2)); + if (!compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))) + return false; + break; case ARRAY_TYPE: /* Target types must match incl. qualifiers. */ - return comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION)); + if (!comp_array_types (t1, t2, !!(strict & COMPARE_REDECLARATION))) + return false; + break; case TEMPLATE_TYPE_PARM: - return (TEMPLATE_TYPE_IDX (t1) == TEMPLATE_TYPE_IDX (t2) - && TEMPLATE_TYPE_LEVEL (t1) == TEMPLATE_TYPE_LEVEL (t2)); + if (TEMPLATE_TYPE_IDX (t1) != TEMPLATE_TYPE_IDX (t2) + || TEMPLATE_TYPE_LEVEL (t1) != TEMPLATE_TYPE_LEVEL (t2)) + return false; + break; case TYPENAME_TYPE: if (!cp_tree_equal (TYPENAME_TYPE_FULLNAME (t1), TYPENAME_TYPE_FULLNAME (t2))) return false; - return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)); + if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))) + return false; + break; case UNBOUND_CLASS_TEMPLATE: if (!cp_tree_equal (TYPE_IDENTIFIER (t1), TYPE_IDENTIFIER (t2))) return false; - return same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2)); + if (!same_type_p (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2))) + return false; + break; case COMPLEX_TYPE: - return same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)); + if (!same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) + return false; + break; case VECTOR_TYPE: - return TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) - && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2)); + if (TYPE_VECTOR_SUBPARTS (t1) != TYPE_VECTOR_SUBPARTS (t2) + || !same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))) + return false; break; default: - break; + return false; } - return false; + + /* If we get here, we know that from a target independent POV the + types are the same. Make sure the target attributes are also + the same. */ + return targetm.comp_type_attributes (t1, t2); } /* Returns 1 if TYPE1 is at least as qualified as TYPE2. */ @@ -1995,8 +2011,8 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree member_name) /*want_type=*/false); member_type = cp_build_qualified_type (TREE_TYPE (member), cp_type_quals (ptrmem_type)); - return fold (build3 (COMPONENT_REF, member_type, - ptrmem, member, NULL_TREE)); + return fold_build3 (COMPONENT_REF, member_type, + ptrmem, member, NULL_TREE); } /* Given an expression PTR for a pointer, return an expression @@ -2343,7 +2359,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) vtbl = build_indirect_ref (vtbl, NULL); /* Finally, extract the function pointer from the vtable. */ - e2 = fold (build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx)); + e2 = fold_build2 (PLUS_EXPR, TREE_TYPE (vtbl), vtbl, idx); e2 = build_indirect_ref (e2, NULL); TREE_CONSTANT (e2) = 1; TREE_INVARIANT (e2) = 1; -- 2.11.4.GIT