diff mbox

[middle-end,c,c++] : Optimize cost of comp_type_attributes

Message ID AANLkTimCbGTLuiHdOXP7XbmK1+NfkKYi58ipdLk4HrO6@mail.gmail.com
State New
Headers show

Commit Message

Kai Tietz March 24, 2011, 5:06 p.m. UTC 
2011/3/24 Jason Merrill <jason@redhat.com>:
> How about splitting this out into a separate function that can compare
> either list or expression arguments?  That would also be useful for
> merge_attributes and attribute_list_contained.
>
> Jason
>

Ok, here is the patch

ChangeLog gcc/

2011-03-11  Kai Tietz

       * 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_equal): New static helper function.
       (comp_type_attributes): New function.
       (merge_attributes): Use attribute_equal for comparison.
       (attribute_list_contained): Likewise.
       * tree.h (comp_type_attributes): New prototype.

ChangeLog cp/

2011-03-11  Kai Tietz

       * 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.

Regards,
Kai

Comments

Jason Merrill March 24, 2011, 5:11 p.m. UTC | #1 
On 03/24/2011 06:06 PM, Kai Tietz wrote:
> +/* Compare two attributes for identity.  Return true if the attributes
> +   are known to be equal; otherwise return false.  */
> +
> +static bool
> +attribute_equal (const_tree attr1, const_tree attr2)
> +{
> +  if (attr1 == attr2)
> +    return true;
> +

Shouldn't this compare the TREE_VALUEs?

This function is also assuming that the TREE_PURPOSEs name the same 
attribute.  I had figured that we would pull out the TREE_VALUE in the 
caller, but doing it in here is fine too as long as the function is 
documented as making that assumption.

Jason
diff mbox

Patch

Index: gcc/gcc/c-typeck.c
===================================================================
--- gcc.orig/gcc/c-typeck.c	2011-03-24 08:23:42.441173500 +0100
+++ gcc/gcc/c-typeck.c	2011-03-24 09:24:53.445892300 +0100
@@ -1079,7 +1079,7 @@  comptypes_internal (const_tree type1, co
     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.  */
Index: gcc/gcc/cp/decl.c
===================================================================
--- gcc.orig/gcc/cp/decl.c	2011-03-24 08:23:42.443173500 +0100
+++ gcc/gcc/cp/decl.c	2011-03-24 09:24:53.573408500 +0100
@@ -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;
Index: gcc/gcc/cp/search.c
===================================================================
--- gcc.orig/gcc/cp/search.c	2011-03-24 08:23:42.444173500 +0100
+++ gcc/gcc/cp/search.c	2011-03-24 09:24:53.645417600 +0100
@@ -1897,7 +1897,7 @@  check_final_overrider (tree overrider, t
     }
 
   /* 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);
Index: gcc/gcc/cp/typeck.c
===================================================================
--- gcc.orig/gcc/cp/typeck.c	2011-03-24 08:23:42.495173500 +0100
+++ gcc/gcc/cp/typeck.c	2011-03-24 09:24:53.697424200 +0100
@@ -1338,7 +1338,7 @@  structural_comptypes (tree t1, tree t2,
   /* 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
Index: gcc/gcc/gimple.c
===================================================================
--- gcc.orig/gcc/gimple.c	2011-03-24 08:23:42.496173500 +0100
+++ gcc/gcc/gimple.c	2011-03-24 09:24:53.793936500 +0100
@@ -3615,7 +3615,7 @@  gimple_types_compatible_p_1 (tree t1, tr
 			 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))
Index: gcc/gcc/tree-ssa.c
===================================================================
--- gcc.orig/gcc/tree-ssa.c	2011-03-24 08:23:42.498173500 +0100
+++ gcc/gcc/tree-ssa.c	2011-03-24 09:24:53.831441200 +0100
@@ -1438,7 +1438,7 @@  useless_type_conversion_p (tree outer_ty
 
       /* 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;
     }
Index: gcc/gcc/tree.c
===================================================================
--- gcc.orig/gcc/tree.c	2011-03-24 08:23:42.499173500 +0100
+++ gcc/gcc/tree.c	2011-03-24 18:00:04.398084700 +0100
@@ -4283,7 +4283,7 @@  build_type_attribute_qual_variant (tree
 	 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);
@@ -4296,6 +4296,74 @@  build_type_attribute_qual_variant (tree
   return ttype;
 }
 
+/* Compare two attributes for identity.  Return true if the attributes
+   are known to be equal; otherwise return false.  */
+
+static bool
+attribute_equal (const_tree attr1, const_tree attr2)
+{
+  if (attr1 == 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_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.
@@ -5296,23 +5364,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_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);
@@ -6250,24 +6305,12 @@  attribute_list_contained (const_tree l1,
 	 const_tree.  */
       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
 				    CONST_CAST_TREE(l1));
-	   attr != NULL_TREE;
+	   attr != NULL_TREE && !attribute_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;
     }
 
Index: gcc/gcc/tree.h
===================================================================
--- gcc.orig/gcc/tree.h	2011-03-24 08:23:42.619173500 +0100
+++ gcc/gcc/tree.h	2011-03-24 09:24:54.041968000 +0100
@@ -4286,6 +4286,11 @@  extern tree build_type_attribute_variant
 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
 {