From 6a20ce76e592b8a3a962a17b7dfaca8e36eb5067 Mon Sep 17 00:00:00 2001 From: Richard Guenther Date: Tue, 24 May 2011 14:33:48 +0000 Subject: [PATCH] gimple.c (compare_type_names_p): Remove for_completion_p arg. 2011-05-24 Richard Guenther * gimple.c (compare_type_names_p): Remove for_completion_p arg. (gimple_compatible_complete_and_incomplete_subtype_p): Remove. (gimple_types_compatible_p_1): Adjust. (iterative_hash_canonical_type): Do not bother about complete vs. incomplete types. (gimple_canonical_types_compatible_p): Likewise. From-SVN: r174118 --- gcc/ChangeLog | 9 ++++++ gcc/gimple.c | 77 ++++++++------------------------------------------- 2 files changed, 20 insertions(+), 66 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 1f658ebc7cf..38d250fe70a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,12 @@ +2011-05-24 Richard Guenther + + * gimple.c (compare_type_names_p): Remove for_completion_p arg. + (gimple_compatible_complete_and_incomplete_subtype_p): Remove. + (gimple_types_compatible_p_1): Adjust. + (iterative_hash_canonical_type): Do not bother about complete vs. + incomplete types. + (gimple_canonical_types_compatible_p): Likewise. + 2011-05-24 Rainer Orth * config/i386/sol2.h (FORCE_CODE_SECTION_ALIGN): Remove. diff --git a/gcc/gimple.c b/gcc/gimple.c index 4c0e4a387df..823892cb621 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -3333,33 +3333,18 @@ gimple_lookup_type_leader (tree t) true if both types have no names. */ static bool -compare_type_names_p (tree t1, tree t2, bool for_completion_p) +compare_type_names_p (tree t1, tree t2) { tree name1 = TYPE_NAME (t1); tree name2 = TYPE_NAME (t2); - /* Consider anonymous types all unique for completion. */ - if (for_completion_p - && (!name1 || !name2)) - return false; - if (name1 && TREE_CODE (name1) == TYPE_DECL) - { - name1 = DECL_NAME (name1); - if (for_completion_p - && !name1) - return false; - } - gcc_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE); + name1 = DECL_NAME (name1); + gcc_checking_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE); if (name2 && TREE_CODE (name2) == TYPE_DECL) - { - name2 = DECL_NAME (name2); - if (for_completion_p - && !name2) - return false; - } - gcc_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE); + name2 = DECL_NAME (name2); + gcc_checking_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE); /* Identifiers can be compared with pointer equality rather than a string comparison. */ @@ -3420,25 +3405,6 @@ gimple_compare_field_offset (tree f1, tree f2) return false; } -/* If the type T1 and the type T2 are a complete and an incomplete - variant of the same type return true. */ - -static bool -gimple_compatible_complete_and_incomplete_subtype_p (tree t1, tree t2) -{ - /* If one pointer points to an incomplete type variant of - the other pointed-to type they are the same. */ - if (TREE_CODE (t1) == TREE_CODE (t2) - && RECORD_OR_UNION_TYPE_P (t1) - && (!COMPLETE_TYPE_P (t1) - || !COMPLETE_TYPE_P (t2)) - && TYPE_QUALS (t1) == TYPE_QUALS (t2) - && compare_type_names_p (TYPE_MAIN_VARIANT (t1), - TYPE_MAIN_VARIANT (t2), true)) - return true; - return false; -} - static bool gimple_types_compatible_p_1 (tree, tree, type_pair_t, VEC(type_pair_t, heap) **, @@ -3588,7 +3554,7 @@ gimple_types_compatible_p_1 (tree t1, tree t2, type_pair_t p, state->u.same_p = 1; /* The struct tags shall compare equal. */ - if (!compare_type_names_p (t1, t2, false)) + if (!compare_type_names_p (t1, t2)) goto different_types; /* If their attributes are not the same they can't be the same type. */ @@ -4391,27 +4357,11 @@ iterative_hash_canonical_type (tree type, hashval_t val) if (TREE_CODE (type) == METHOD_TYPE) v = iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type), v); - /* For result types allow mismatch in completeness. */ - if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type))) - { - v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v); - v = iterative_hash_name - (TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v); - } - else - v = iterative_hash_canonical_type (TREE_TYPE (type), v); + v = iterative_hash_canonical_type (TREE_TYPE (type), v); for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p)) { - /* For argument types allow mismatch in completeness. */ - if (RECORD_OR_UNION_TYPE_P (TREE_VALUE (p))) - { - v = iterative_hash_hashval_t (TREE_CODE (TREE_VALUE (p)), v); - v = iterative_hash_name - (TYPE_NAME (TYPE_MAIN_VARIANT (TREE_VALUE (p))), v); - } - else - v = iterative_hash_canonical_type (TREE_VALUE (p), v); + v = iterative_hash_canonical_type (TREE_VALUE (p), v); na++; } @@ -4700,10 +4650,7 @@ gimple_canonical_types_compatible_p (tree t1, tree t2) case FUNCTION_TYPE: /* Function types are the same if the return type and arguments types are the same. */ - if (!gimple_compatible_complete_and_incomplete_subtype_p - (TREE_TYPE (t1), TREE_TYPE (t2)) - && !gimple_canonical_types_compatible_p - (TREE_TYPE (t1), TREE_TYPE (t2))) + if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))) return false; if (!comp_type_attributes (t1, t2)) @@ -4719,10 +4666,8 @@ gimple_canonical_types_compatible_p (tree t1, tree t2) parms1 && parms2; parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2)) { - if (!gimple_compatible_complete_and_incomplete_subtype_p - (TREE_VALUE (parms1), TREE_VALUE (parms2)) - && !gimple_canonical_types_compatible_p - (TREE_VALUE (parms1), TREE_VALUE (parms2))) + if (!gimple_canonical_types_compatible_p + (TREE_VALUE (parms1), TREE_VALUE (parms2))) return false; }