gimple.c (compare_type_names_p): Remove for_completion_p arg.

2011-05-24  Richard Guenther  <rguenther@suse.de>

	* 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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1f658ebc7cf75e5127a3ea834b2f61a02dcdfd73..38d250fe70a14053b5517bd105dc840ea903244b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,12 @@
+2011-05-24  Richard Guenther  <rguenther@suse.de>
+
+       * 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  <ro@CeBiTec.Uni-Bielefeld.DE>
 
        * config/i386/sol2.h (FORCE_CODE_SECTION_ALIGN): Remove.

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 4c0e4a387df2abaf28332e1275184d94652a9247..823892cb6218b45a4a1e2a5c757fcda37ea5463f 100644 (file)
--- 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;
            }