ChangeLog gcc/

2011-03-25  Kai Tietz  <ktietz@redhat.com>

	* c-typeck.c (comptypes_internal): Replace target
	hook call of comp_type_attributes by version in tree.c file.
	* gimple.c (gimple_types_compatible_p_1): Likewise.
	* tree-ssa.c (useless_type_conversion_p): Likewise.
	* tree.c (build_type_attribute_qual_variant): Likewise.
	(attribute_value_equal): New static helper function.
	(comp_type_attributes): New function.
	(merge_attributes): Use attribute_value_equal for comparison.
	(attribute_list_contained): Likewise.
	* tree.h (comp_type_attributes): New prototype.

ChangeLog cp/
2011-03-25  Kai Tietz  <ktietz@redhat.com>

        * decl.c (decls_match): Replace target hook
        call of comp_type_attributes by version in tree.c file.
        * search.c (check_final_overrider): Likewise.
        * typeck.c (structural_comptypes): Likewise.

From-SVN: r171445

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 5fdfec9e3629a419c5e0212c78ce30c27ffc6147..ee9130e663b170e721d5ba1fe278a1e67591fe44 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,16 @@
+2011-03-25  Kai Tietz  <ktietz@redhat.com>
+
+       * c-typeck.c (comptypes_internal): Replace target
+       hook call of comp_type_attributes by version in tree.c file.
+       * gimple.c (gimple_types_compatible_p_1): Likewise.
+       * tree-ssa.c (useless_type_conversion_p): Likewise.
+       * tree.c (build_type_attribute_qual_variant): Likewise.
+       (attribute_value_equal): New static helper function.
+       (comp_type_attributes): New function.
+       (merge_attributes): Use attribute_value_equal for comparison.
+       (attribute_list_contained): Likewise.
+       * tree.h (comp_type_attributes): New prototype.
+
 2011-03-25  Richard Guenther  <rguenther@suse.de>
 
        * tree-cfg.c (verify_gimple_assign_unary): Drop special casing

diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index a22bb737533affc203de69609b7a860e4b4ca449..049a8af8330821d599981cab84dcc0a6e77ee854 100644 (file)
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -1079,7 +1079,7 @@ comptypes_internal (const_tree type1, const_tree type2, bool *enum_and_int_p,
     return 1;
 
   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
-  if (!(attrval = targetm.comp_type_attributes (t1, t2)))
+  if (!(attrval = comp_type_attributes (t1, t2)))
      return 0;
 
   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index b8069a81ce759f1b49e8b9b0c441cfaff955f993..8bf29c7a4578e9fdb5a257c568f8177379f2548e 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2011-03-25  Kai Tietz  <ktietz@redhat.com>
+
+       * decl.c (decls_match): Replace target hook
+       call of comp_type_attributes by version in tree.c file.
+       * search.c (check_final_overrider): Likewise.
+       * typeck.c (structural_comptypes): Likewise.
+
 2011-03-21  Kai Tietz  <ktietz@redhat.com>
 
        PR target/12171

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 0985749f32a3502438681099c314bd8fc82da2ad..895527c2c3e48156e64cb055c396eda198009996 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -1012,8 +1012,8 @@ decls_match (tree newdecl, tree olddecl)
            types_match =
              compparms (p1, p2)
              && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
-                 || targetm.comp_type_attributes (TREE_TYPE (newdecl),
-                                                  TREE_TYPE (olddecl)) != 0);
+                 || comp_type_attributes (TREE_TYPE (newdecl),
+                                          TREE_TYPE (olddecl)) != 0);
        }
       else
        types_match = 0;

diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 07ec9efd336ada4a57a3f599eee43756629c67aa..9ec6fc31963172daf80612229beb853b3ff1e387 100644 (file)
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -1897,7 +1897,7 @@ check_final_overrider (tree overrider, tree basefn)
     }
 
   /* Check for conflicting type attributes.  */
-  if (!targetm.comp_type_attributes (over_type, base_type))
+  if (!comp_type_attributes (over_type, base_type))
     {
       error ("conflicting type attributes specified for %q+#D", overrider);
       error ("  overriding %q+#D", basefn);

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 955ff578f11fd17335eb9ef45a34efa3b05293fe..a45ed2d7f044008d014fefbf5c03b9f888436436 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -1338,7 +1338,7 @@ structural_comptypes (tree t1, tree t2, int strict)
   /* 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);
+  return comp_type_attributes (t1, t2);
 }
 
 /* Return true if T1 and T2 are related as allowed by STRICT.  STRICT

diff --git a/gcc/gimple.c b/gcc/gimple.c
index 5af3cd463a19fdd3782153f793a7f9c1f460b502..7f29bd01e4053502acba900af76578c4a0e59d19 100644 (file)
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -3615,7 +3615,7 @@ gimple_types_compatible_p_1 (tree t1, tree t2, enum gtc_mode mode,
                         state, sccstack, sccstate, sccstate_obstack))
        goto different_types;
 
-      if (!targetm.comp_type_attributes (t1, t2))
+      if (!comp_type_attributes (t1, t2))
        goto different_types;
 
       if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))

diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index d542e0a253a1c2ed5e21ab760bb4d53f0d100113..05eb2a22e2eca30f30f4694f8fdcb7637d7c9183 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -1438,7 +1438,7 @@ useless_type_conversion_p (tree outer_type, tree inner_type)
 
       /* Defer to the target if necessary.  */
       if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
-       return targetm.comp_type_attributes (outer_type, inner_type) != 0;
+       return comp_type_attributes (outer_type, inner_type) != 0;
 
       return true;
     }

diff --git a/gcc/tree.c b/gcc/tree.c
index 6f22be4992a234a08eb6a9d0cf094cee04b575d2..ef6a812ddf01db7ef808d21eb431e384c4da18ac 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -4287,7 +4287,7 @@ build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
         its canonical type, we will need to use structural equality
         checks for this type. */
       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
-          || !targetm.comp_type_attributes (ntype, ttype))
+          || !comp_type_attributes (ntype, ttype))
        SET_TYPE_STRUCTURAL_EQUALITY (ntype);
       else if (TYPE_CANONICAL (ntype) == ntype)
        TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
@@ -4300,6 +4300,75 @@ build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
   return ttype;
 }
 
+/* Compare two attributes for their value identity.  Return true if the
+   attribute values are known to be equal; otherwise return false.
+*/
+
+static bool
+attribute_value_equal (const_tree attr1, const_tree attr2)
+{
+  if (TREE_VALUE (attr1) == TREE_VALUE (attr2))
+    return true;
+
+  if (TREE_VALUE (attr1) != NULL_TREE
+      && TREE_CODE (TREE_VALUE (attr1)) == TREE_LIST
+      && TREE_VALUE (attr2) != NULL
+      && TREE_CODE (TREE_VALUE (attr2)) == TREE_LIST)
+    return (simple_cst_list_equal (TREE_VALUE (attr1),
+                                  TREE_VALUE (attr2)) == 1);
+
+  return (simple_cst_equal (TREE_VALUE (attr1), TREE_VALUE (attr2)) == 1);
+}
+
+/* Return 0 if the attributes for two types are incompatible, 1 if they
+   are compatible, and 2 if they are nearly compatible (which causes a
+   warning to be generated).  */
+int
+comp_type_attributes (const_tree type1, const_tree type2)
+{
+  const_tree a1 = TYPE_ATTRIBUTES (type1);
+  const_tree a2 = TYPE_ATTRIBUTES (type2);
+  const_tree a;
+
+  if (a1 == a2)
+    return 1;
+  for (a = a1; a != NULL_TREE; a = TREE_CHAIN (a))
+    {
+      const struct attribute_spec *as;
+      const_tree attr;
+
+      as = lookup_attribute_spec (TREE_PURPOSE (a));
+      if (!as || as->affects_type_identity == false)
+        continue;
+
+      attr = lookup_attribute (as->name, CONST_CAST_TREE (a2));
+      if (!attr || !attribute_value_equal (a, attr))
+        break;
+    }
+  if (!a)
+    {
+      for (a = a2; a != NULL_TREE; a = TREE_CHAIN (a))
+       {
+         const struct attribute_spec *as;
+
+         as = lookup_attribute_spec (TREE_PURPOSE (a));
+         if (!as || as->affects_type_identity == false)
+           continue;
+
+         if (!lookup_attribute (as->name, CONST_CAST_TREE (a1)))
+           break;
+         /* We don't need to compare trees again, as we did this
+            already in first loop.  */
+       }
+      /* All types - affecting identity - are equal, so
+         there is no need to call target hook for comparison.  */
+      if (!a)
+        return 1;
+    }
+  /* As some type combinations - like default calling-convention - might
+     be compatible, we have to call the target hook to get the final result.  */
+  return targetm.comp_type_attributes (type1, type2);
+}
 
 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
    is ATTRIBUTE.
@@ -5300,23 +5369,10 @@ merge_attributes (tree a1, tree a2)
              tree a;
              for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
                                         attributes);
-                  a != NULL_TREE;
+                  a != NULL_TREE && !attribute_value_equal (a, a2);
                   a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
                                         TREE_CHAIN (a)))
-               {
-                 if (TREE_VALUE (a) != NULL
-                     && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
-                     && TREE_VALUE (a2) != NULL
-                     && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
-                   {
-                     if (simple_cst_list_equal (TREE_VALUE (a),
-                                                TREE_VALUE (a2)) == 1)
-                       break;
-                   }
-                 else if (simple_cst_equal (TREE_VALUE (a),
-                                            TREE_VALUE (a2)) == 1)
-                   break;
-               }
+               ;
              if (a == NULL_TREE)
                {
                  a1 = copy_node (a2);
@@ -6254,24 +6310,12 @@ attribute_list_contained (const_tree l1, const_tree l2)
         const_tree.  */
       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
                                    CONST_CAST_TREE(l1));
-          attr != NULL_TREE;
+          attr != NULL_TREE && !attribute_value_equal (t2, attr);
           attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
                                    TREE_CHAIN (attr)))
-       {
-         if (TREE_VALUE (t2) != NULL
-             && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
-             && TREE_VALUE (attr) != NULL
-             && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
-           {
-             if (simple_cst_list_equal (TREE_VALUE (t2),
-                                        TREE_VALUE (attr)) == 1)
-               break;
-           }
-         else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
-           break;
-       }
+       ;
 
-      if (attr == 0)
+      if (attr == NULL_TREE)
        return 0;
     }
 

diff --git a/gcc/tree.h b/gcc/tree.h
index 454d3287b4802923fac663cd8cce19a338afbf1e..9a288cb69ac100bde2a365c14c0dab5a1ebd9543 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4286,6 +4286,11 @@ extern tree build_type_attribute_variant (tree, tree);
 extern tree build_decl_attribute_variant (tree, tree);
 extern tree build_type_attribute_qual_variant (tree, tree, int);
 
+/* Return 0 if the attributes for two types are incompatible, 1 if they
+   are compatible, and 2 if they are nearly compatible (which causes a
+   warning to be generated).  */
+extern int comp_type_attributes (const_tree, const_tree);
+
 /* Structure describing an attribute and a function to handle it.  */
 struct attribute_spec
 {